Diskrete Mathematik 1 - CITS - Ruhr-Universität Bochum

Ruhr-Universität Bochum
Lehrstuhl für Kryptologie und IT-Sicherheit
Prof. Dr. Alexander May
M. Ritzenhofen, M. Mansour Al Sawadi, A. Meurer
Lösungsblatt zur Vorlesung
Diskrete Mathematik 1
WS 2008/09
Blatt 13 / 27. Januar 2009 / Abgabe bis 02. Februar 2009, 08.00 Uhr, in
die Kästen auf NA 02
AUFGABE 1 (4 Punkte):
Geben Sie die folgende lineare Rekursionsgleichung in expliziter Form an, d.h. stellen Sie die
Erzeugende Funktion auf und formen diese zu einer Reihendarstellung um, aus der Sie die
explizite Darstellung der a n ablesen können:
wobei a 0 = 0, a 1 = 1 .
a n := 2a n−1 − a n−2 , n ≥ 2 ,
Lösungsvorschlag:
Verwenden der Rekursionsgleichung und der Anfangsbedingungen ergibt:
∑
a n x n = ∑ 2a n−1 x n − ∑ a n−2 x n + 1 · x + 0
n≥0 n≥2 n≥2
= 2x ∑ a n x n − x ∑ 2 a n x n + x
n≥1
n≥0
( )
∑
= 2x a n x n − 0 − x ∑ 2 a n x n + x
n≥0
n≥0

Einsetzen von A(x) = ∑ n≥0 a nx n ergibt:
A(x) = 2xA(x) − x 2 A(x) + x
⇔ A(x) =
x
x 2 − 2x + 1
= x − 1
(x − 1) + 1
2 (x − 1) 2
=
1
(x − 1) + 1
(x − 1) 2
= − ∑ n≥0
= ∑ n≥0
nx n
x n + ∑ n≥0
(n + 1)x n
Es gilt also a n = n.
AUFGABE 2 (6 Punkte):
Bestimmen Sie die asymptotischen oberen und unteren Schranken für T (n) unter der Annahme,
dass T (n) konstant ist für n ≤ 2.
(a) T (n) = 3T ( n
2
)
+ n log n
(b) T (n) = 2T ( n
4
)
+
√ n
(c) T (n) = 9T ( n
10)
+ n
(d) T (n) = T ( √ n) + 1
Lösungsvorschlag:
(a) Mit den Bezeichnungen des Master-Theorems ist hier f(n) = n log n, a = 3 und b = 2.
Sei log 2 3 − 1 > δ > 0. Dann existiert ein n 0 ∈ N so, dass log n ≤ n δ gilt für alle n ≥ n 0 ,
denn:
log n
lim
n→∞ n δ
= lim
1
n
n→∞
= lim
δnδ−1 n→∞
1
δn δ = 0.
Also folgt f(n) = n log n ≤ n 1+δ ≤ n log 2 3−ɛ für ein 0 < ɛ < log 2 3 − 1 − δ. Damit ist
f(n) = O(n log 2 3−ɛ ) und mit dem Master-Theorem (Fall 1) folgt:
T (n) = Θ(n log 2 3−ɛ ).
(b) Mit den Bezeichnungen des Master-Theorems ist hier f(n) = √ n = n 1 2 , a = 2 und
b = 4. Also ist f(n) = n 1 2 = n log 4 2 = Θ(n log 4 2 ). Mit dem Master-Theorem (Fall 2) folgt
T (n) = Θ(n log 4 2 log n).

(c) Mit den Bezeichnungen des Master-Theorems ist hier f(n) = n, a = 9 und b = 10. Es
gilt log 10 9 < 1. Also ist f(n) = n = Ω(n log 10 9+ɛ ) für ein 0 < ɛ < 1 − log 10 9. Außerdem
gilt 9f( n ) = 9 n = 9 f(n) < f(n). Mit dem Master-Theorem (Fall 3) folgt daher
10 10 10
T (n) = Θ(n).
(d) Auf diese Rekursion lässt sich das Master-Theorem nicht anwenden, so dass wir die
Rekursion explizit durchführen.
T (n) = T ( √ n) + 1
= T (n 1 4 ) + 2 · 1
= T (n 1
2 j ) + j · 1
Die Rekursion kann abgebrochen werden, sobald das Argument kleiner oder gleich 2
ist, also falls n 1
2 j ≤ 2. Dies ist äquivalent zu j ≥ log log n. Einsetzen ergibt:
1
T (n) = T (n 2 log log n ) + log log n · 1
= Θ(1) + log log n
= Θ(log log n).
AUFGABE 3 (4 Punkte):
Wir betrachten das Problem, n Dollar-Cent aus Münzen so zusammenzusetzen, dass möglichst
wenige Münzen benötigt werden. Geben Sie einen Greedy-Algorithmus an, der eine solche Zusammensetzung
aus Quarters (25Cent), Dimes (10Cent), Nickels (5Cent) und Pennys (1Cent)
erstellt. Zeigen Sie, dass Ihr Algorithmus eine optimale Lösung ausgibt.
Lösungsvorschlag:
Algorithm 1 Optimize Coins
Eingabe: n ∈ N
c := [0, 0, 0, 0] % initialiere alle Anzahlen von Münzen mit 0
while n ≥ 25 do
c[1] ← c[1] + 1; n ← n − 25;
end while
while n ≥ 10 do
c[2] ← c[2] + 1; n ← n − 10;
end while
while n ≥ 5 do
c[3] ← c[3] + 1; n ← n − 5;
end while
c[4] ← n;
Um die Korrektheit des Algorithmus zu zeigen, genügt es zu zeigen, dass eine optimale Lösung
immer die Münze mit größtmöglichem Wert g enthalten muss. Induktiv folgt dann die Optimalität
von c, da sich c aus einer optimalen Lösung für den Fall n − g und einer Münze mit

Wert g zusammensetzt. Sei also nun n die Eingabe des Algorithmus mit n ≥ 25 und c die
optimale Lösung, n in wenigen Münzen darzustellen. Angenommen c[1] = 0, das heißt, in c
komme kein Quarter vor.
1.Fall: c[2] ≥ 3. Dann ersetze man 3 Dimes durch ein Quarter und ein Nickel und erhält eine
Lösung mit weniger Münzen, was einen Widerspruch zur Optimalität von c bildet.
2.Fall: c[2] = 2 und c[3] ≥ 1: Man ersetze zwei Dimes und ein Nickel durch ein Quater, was
wiederum einen Widerspruch zur Optimalität von c bildet.
3.Fall: c[2] = 2 und c[3] = 0: Wegen n ≥ 25 folgt dann c[4] ≥ 5 und man ersetze zwei Dimes
und fünf Pennys durch ein Quater, wieder ein Widerspruch zur Optimalität von c.
4.Fall: c[2] = 1: Dann gilt c[3] + c[4] ≥ 3, da mindestens drei Nickels erforderlich sind, um
den Wert n ≥ 25 zu erreichen. Man ersetze den Dime und die passenden Nickels und/oder
Pennys durch ein Quater, was einen Widerspruch zur Optimaltät von c bildet.
5.Fall: c[2] = 0: Dann ist c[3] + c[4] ≥ 5, da mindestens fünf Nickels erforderlich sind, um
den Wert n ≥ 25 zu erreichen. Man ersetze den Dime und die passenden Nickels und/oder
Pennys durch ein Quater, was einen Widerspruch zur Optimaltät von c bildet.
Analog lässt sich in den Fällen 25 > n ≥ 10 und 10 > n ≥ 5 argumentieren. Damit ist die
Optimalität von c gezeigt.
AUFGABE 4 (6 Punkte):
Geben Sie einen Algorithmus zur Lösung des Scheduling-Problems mittels Dynamischer Programmierung
an. Zeigen Sie dessen Korrektheit und bestimmen Sie die Laufzeit.
Lösungsvorschlag:
Es bezeichne J[l, r] eine optimale kompatible Menge aus den Mengen mit Indizes l bis r.
Algorithm 2 Dyn-Scheduling
Eingabe: s[1..n] und f[1..n], n ∈ N mit f[1] ≤ f[2] ≤ . . . , ≤ f[n]
for i = 1 to n do
J[i, i] → i
end for
for l = 2 to n do
for i = 1 to n − (l − 1) do
j → i + (l − 1)
J[i, j] → Max(Kombiniere(J[i, k], J[k + 1, j]), k = i, . . . , j − 1)
end for
end for
Ausgabe: J[1, n]
Die Funktion Max ist dabei eine Funktion, die über die Kardinalität der Mengen optimiert.
In jedem Schritt wird also J[i, j] so gewählt, dass es möglichst viele Elemente enthält. Bei
gleicher Kardinalität wird das erste Element gewählt.
Die Hilfsfunktion Kombiniere funktioniert folgendermaßen:

Algorithm 3 Kombiniere
Eingabe: J[l, k] und J[k + 1, r]
m1 ← max{m ∈ J[l, k]}
m2 ← min{m ∈ J[k + 1, r]}
if f m1 < s m2 then
J[l, r] → J[l, k] ∪ J[k + 1, r]
else
J[l, r] → Max(J[l, k], J[k + 1, r])
end if
Ausgabe: J[l, r]
Korrektheit des Algorithmus: Der Algorithmus terminiert, da über vorgegebene Paramter
iteriert wird, also keine Endlossschleifen entstehen können.
Durch den Parameter l wachsen die Intervalllängen stetig. Außerdem werden so nur bekannte
Mengen verwendet. Zu zeigen bleibt, dass sich eine optimale kompatible Menge durch Kombiniere
aus zwei optimalen kompatiblen Mengen ergibt. Dann entsteht in jedem Schritt
beim Zusammensetzen eine neue optimale kompatible Menge, da die Anfangsmengen J[i, i]
optimale kompatible Mengen sind.
Sei also J[l, r] eine optimale kompatible Menge aus {l, . . . , r}. Sei zunächst |J[l, r]| = 1. Dann
gilt s t < f l ≤ f s für t = l + 1, . . . , r und s = l + 1, . . . , r, da J[l, r] sonst nicht optimal und
kompatibel wäre. Somit enthält jedes beliebige J[l, k] oder J[k + 1, r] nur ein Element und
ist damit optimal. Also ergibt sich J[l, r] als Kombiniere von zwei optimalen kompatiblen
Mengen.
Sei nun |J[l, r]| ≥ 2 und m1, m2 seien zwei aufeinanderfolgende Elemente aus J[l, r].
Behauptung: Dann ist J[l, r] = (J ∩ {l, . . . , t − 1})
} {{ }
J 1
∪ (J ∩ {t, . . . , r})
} {{ }
J 2
für ein m1 ≤ t < m2,
wobei J 1 und J 2 optimale kompatible Mengen sind.
Zunächst einmal gilt s m2 ≥ f m1 , da sonst nicht m1 und m2 Elemente in J wären.
Außerdem gilt für alle m1 < n < m2, dass s n < f m1 oder f n > s m2 . Sonst könnte man n zu
J hinzufügen, was einen Widerspruch sowohl zur Optimalität von J als auch zur Definition
von m1 und m2 bildet.
Wir wählen nun t minimal mit f t > s m2 .
Angenommen, J 1 sei nicht optimal, das heißt es existiert ein J ′ 1 ⊂ {l, . . . , t−1} mit |J ′ 1| > |J 1 |.
Da nach Wahl von t für alle m ∈ J ′ 1 gilt f m ≤ s m2 , ergibt sich ein Widerspruch zur Optimalität
von J[l, r] durch Ersetzen von J 1 durch J ′ 1.
Angenommen, J 2 sei nicht optimal, das heißt es existiert ein J ′ 2 ⊂ {t, . . . , r} mit |J ′ 2| > |J 2 |.
Dann gilt für alle m ∈ J ′ 2, dass m ≥ m2 ist. Sonst ergibt sich ein Widerspruch zur Definition
von m1 und m2 und J[l, r].
Ersetzen von J 2 durch J ′ 2 in J[l, r] ergibt aber wieder eine kompatible Menge J ′ [l, r] mit
|J ′ [l, r]| > |J ′ [l, r]|. Dies bildet einen Widerspruch zur Optimalität von J[l, r].
Laufzeit des Algorithmus: Der Durchlauf der ersten FOR-Scheife benötigt Laufzeit O(n),
da Wertzuweisungen in O(1) liegen. Die zweite FOR-Schleife wird ∑ n
n(n−1)
l=2
(n − l + 1) = -
2

mal aufgerufen. Darin werden j − 1 ≤ n Aufrufe von Kombiniere getätigt. Die Laufzeit von
Kombiniere ist wiederum O(1).
Die Gesamtlaufzeit ist daher O(n 3 ).