2. Übung – Algorithmen Ialgo2.iti.kit.edu/documents/algo1-2014/uebung_02.pdf · 1 Julian Arz, Timo Bingmann, Sebastian Schlag 2. Übung – Algorithmen I Fakultät für Informatik

1 Julian Arz, Timo Bingmann, Sebastian Schlag2. Übung – Algorithmen I

Fakultät für InformatikInstitut für Theoretische Informatik

INSTITUT FÜR THEORETISCHE INFORMATIK, PROF. SANDERS

2. Übung – Algorithmen IJulian Arz, Timo Bingmann, Sebastian Schlag

KIT – Universität des Landes Baden-Württemberg undnationales Forschungszentrum in der Helmholtz-Gemeinschaft www.kit.edu

Häufige Formen von Rekurrenzen



Allgemeine Rekurrenz / Rekursionsgleichung:

T (g(n)) = A(T ,n)

g : N→ N Funktion die Wachstum der Rekurrenz definiert.A(T , n) ein Ausdruck der T (n) und n enthält.z.B. g(n) = 2n, A(T , n) = 2T (n) + 2n − 1

Lineare Rekurrenz k -ter Ordnung:

T (n) = a1T (n − 1) + a2T (n − 2) + · · ·+ akT (n − k)

mit k Koeffizienten ai und Anfangswerten T (i) = bi für i = 1, . . . , k .

In der Informatik oft: Rekurrenzen aus Divide-Conquer Algorithmen

T (n) = aT(n

b

)+ f (n) .

MastertheoremWiederholung - Einfache Form



Für positive Konstanten a, b, c, d , sei n = bk für ein k ∈ N.

T (n) =

a falls n = 1 Basisfall

cn + dT(n

b

)falls n > 1⇒ teile und herrsche.

Es gilt

T (n) =

Θ(n) falls d < bΘ(n log n) falls d = bΘ(nlogb d

)falls d > b .

Variablenwechsel



T (n) = T (√

n) + 1 für n = 22i, T (4) = 1

Variablenwechsel



T (n) = T (√

n) + 1

Setze m = log n, also n = 2m.Dann:

T (2m) = T (2m2 ) + 1

Variablenwechsel



T (2m) = T (2m2 ) + 1

Trick: setze S(m) := T (2m)

liefert:

S(m) = S(m

2

)+ 1

S(m) = O(?)

Variablenwechsel



T (2m) = T (2m2 ) + 1

Trick: setze S(m) := T (2m)

liefert:

S(m) = S(m

2

)+ 1

S(m) = O(log m)

Variablenwechsel



T (n) = T (√

n) + 1S(m) = S(m

2 ) + 1

S(m) = O(log m)

liefert für n = 22i:

T (n) = T (2m)

= S(m)

= O(log m)

= O(log log n) .

Erzeugende Funktionen



„Advanced Guessing“ mit

F (z) =

∞∑n=0

f (n)zn

Partialbruch-Zerlegung



Gesucht: (1− αz)(1− βz) = 1− z − z2.

Aus Koeffizienten-Vergleich mit

(1− αz)(1− βz) = 1− (α + β)z + α · βz2

folgt−(α + β) = −1 und α · β = −1 .

Wegen β = 1− α folgt α · (1− α) = −1.Es ist also die quadratische Gleichung

α− α2 + 1 = 0 ⇐⇒ α2 − α− 1 = 0

zu lösen.Mit „Mitternachtsformel” folgt

α =1±√

1 + 42

=1±√

52

.




Gesucht: (1− αz)(1− βz) = 1− z − z2.


(1− αz)(1− βz) = 1− (α + β)z + α · βz2

folgt−(α + β) = −1 und α · β = −1 .


α− α2 + 1 = 0 ⇐⇒ α2 − α− 1 = 0


α =1±√

1 + 42

=1±√

52

.




Gesucht: (1− αz)(1− βz) = 1− z − z2.


(1− αz)(1− βz) = 1− (α + β)z + α · βz2

folgt−(α + β) = −1 und α · β = −1 .


α− α2 + 1 = 0 ⇐⇒ α2 − α− 1 = 0

zu lösen.

Mit „Mitternachtsformel” folgt

α =1±√

1 + 42

=1±√

52

.




Gesucht: (1− αz)(1− βz) = 1− z − z2.


(1− αz)(1− βz) = 1− (α + β)z + α · βz2

folgt−(α + β) = −1 und α · β = −1 .


α− α2 + 1 = 0 ⇐⇒ α2 − α− 1 = 0


α =1±√

1 + 42

=1±√

52

.




Man nennt

φ := a =1 +√

52

(und φ := b =

1−√

52

)den Goldenen Schnitt und für diese gilt:

φ+ φ = 1 sowie φ · φ = −1 .

Welche für die Zerlegung genau passen, denn

1− z − z2 = (1− φz)(1 + φz) = 1− (φ+ φ)z + (φ · φ)z2 .




Für die Zerlegung F (z) =z

1− z − z2 =a

1− φz+

b1− φz

fehlen noch

die Nenner.

Für diese gilt

z = a(1− φz) + b(1− φz) = a− aφ · z + b − bφ · z ,

also0 = a + b und 1 = −aφ− bφ .

Wegen b = −a ist also

1 = −aφ+ aφ = a(φ− φ) = a(

1 +√

52

− 1−√

52

)= a

(2√

52

).

Man erhält also

a =1√5

und b = − 1√5.





1− z − z2 =a

1− φz+

b1− φz

fehlen noch

die Nenner. Für diese gilt




1 = −aφ+ aφ = a(φ− φ) = a(

1 +√

52

− 1−√

52

)= a

(2√

52

).

Man erhält also

a =1√5

und b = − 1√5.





1− z − z2 =a

1− φz+

b1− φz

fehlen noch





1 = −aφ+ aφ = a(φ− φ) = a(

1 +√

52

− 1−√

52

)= a

(2√

52

).

Man erhält also

a =1√5

und b = − 1√5.





1− z − z2 =a

1− φz+

b1− φz

fehlen noch





1 = −aφ+ aφ = a(φ− φ) = a(

1 +√

52

− 1−√

52

)= a

(2√

52

).

Man erhält also

a =1√5

und b = − 1√5.

Verifikation: Induktion



Behauptung: f (n) = aφn + bφn = 1√5

(φn − φn) .

Induktionsanfänge:f (0) = 1√

5(φ0 − φ0) = 0 X.

f (1) = 1√5

(φ1 − φ1) = 1√5

(1+√

5−1+√

52

)= 1 X.

Induktionsschritt: (n − 2,n − 1)→ n.

f (n) = f (n − 2) + f (n − 1)

= 1√5

(φn−2 − φn−2 + φn−1 − φn−1)

= 1√5

(φn−2(1 + φ)− φn−2(1 + φ))

= 1√5

(φn−2φ2 − φn−2φ2) = 1√5

(φn − φn) X .

mit der Nebenrechnung:

φ2 = 14 (1 +

√5)2 = 1

4 (1 + 2√

5 + 5) =3 +√

52

= 1 +1 +√

52

= 1 + φ .

Verifikation: Induktion



Behauptung: f (n) = aφn + bφn = 1√5

(φn − φn) .

Induktionsanfänge:f (0) = 1√

5(φ0 − φ0) = 0 X.

f (1) = 1√5

(φ1 − φ1) = 1√5

(1+√

5−1+√

52

)= 1 X.

Induktionsschritt: (n − 2,n − 1)→ n.

f (n) = f (n − 2) + f (n − 1)

= 1√5

(φn−2 − φn−2 + φn−1 − φn−1)

= 1√5

(φn−2(1 + φ)− φn−2(1 + φ))

= 1√5

(φn−2φ2 − φn−2φ2) = 1√5

(φn − φn) X .

mit der Nebenrechnung:

φ2 = 14 (1 +

√5)2 = 1

4 (1 + 2√

5 + 5) =3 +√

52

= 1 +1 +√

52

= 1 + φ .

Amortisierte AnalyseBeispiel Binärzähler



000 ↔ 0

001 ↔ 1010 ↔ 2011 ↔ 3100 ↔ 4101 ↔ 5

...β2β1β0 ↔∑

i

βi2i




000 ↔ 0001 ↔ 1

010 ↔ 2011 ↔ 3100 ↔ 4101 ↔ 5

...β2β1β0 ↔∑

i

βi2i




000 ↔ 0001 ↔ 1010 ↔ 2

011 ↔ 3100 ↔ 4101 ↔ 5

...β2β1β0 ↔∑

i

βi2i




000 ↔ 0001 ↔ 1010 ↔ 2011 ↔ 3

100 ↔ 4101 ↔ 5

...β2β1β0 ↔∑

i

βi2i




000 ↔ 0001 ↔ 1010 ↔ 2011 ↔ 3100 ↔ 4

101 ↔ 5...β2β1β0 ↔

∑i

βi2i




000 ↔ 0001 ↔ 1010 ↔ 2011 ↔ 3100 ↔ 4101 ↔ 5

...β2β1β0 ↔∑

i

βi2i




000 ↔ 0001 ↔ 1010 ↔ 2011 ↔ 3100 ↔ 4101 ↔ 5

...β2β1β0 ↔∑

i

βi2i




Binärzähler: zähle von 0 bis mm Inkrementoperationenx =

∑i βi2i

Function binary-increment() :β0 ← β0 + 1i=0 : N≥0while βi = 2 do

βi+1 ← βi+1 + 1βi ← 0i ← i + 1

000 ↔ 0001 ↔ 1010 ↔ 2011 ↔ 3100 ↔ 4101 ↔ 5

...β2β1β0 ↔∑

i

βi2i

Beispiel Binärzählerbinary-increment



001111111001111111




001111111001111111




001111111001111112




001111111001111120




001111111001111200




001111111001112000




001111111001120000




001111111001200000




001111111002000000




001111111010000000




Kostenmodell: Kosten 1 pro Bitflip

001111111010000000




Kostenmodell: Kosten 1 pro Bitflip=⇒ increment worst case O(log m)

001111111010000000




Kostenmodell: Kosten 1 pro BitflipT (m) seien Gesamtkosten für m Operationenamortisierten Kosten pro Operation definiert als T (m)/m

amortisierten Kosten einer Inkrementoperation?

a) O(1) b) O(log m)

Beispiel BinärzählerAggregatmethode



Kochrezept: Schätze T (m) direkt ab

Operation Kosten0000→ 0001 10001→ 0010 20010→ 0011 10011→ 0100 30100→ 0101 10101→ 0110 20110→ 0111 10111→ 1000 4

....

Beobachtung (m Ops):β0 jedes mal gekippt

∑= m

β1 jedes zweite mal gekippt∑

= m2

β2 jedes vierte mal gekippt∑

= m4

β3 jedes achte mal gekippt∑

= m8

....

T (m) ≤ m + m2 + m

4 + m8 ... ≤

∑∞i=0

m2i = 2m

⇒ T (m)m ≤ 2 = O(1)

Beispiel BinärzählerAggregatmethode



Kochrezept: Schätze T (m) direkt ab

Operation Kosten0000→ 0001 10001→ 0010 20010→ 0011 10011→ 0100 30100→ 0101 10101→ 0110 20110→ 0111 10111→ 1000 4

....

Beobachtung (m Ops):β0 jedes mal gekippt

∑= m

β1 jedes zweite mal gekippt∑

= m2

β2 jedes vierte mal gekippt∑

= m4

β3 jedes achte mal gekippt∑

= m8

....

T (m) ≤ m + m2 + m

4 + m8 ... ≤

∑∞i=0

m2i = 2m

⇒ T (m)m ≤ 2 = O(1)

Beispiel BinärzählerBankkontomethode



Allgemein: t1, ..., tm die Laufzeiten der Einzeloperationenti Gebühr für i-te Operationvor jeder Operation erhält Algorithmus Gehalt Galle Operationen müssen aus Gehältern bezahlt werdenfinde Gehalt G, sodass T (m) ≤ mG




finde Gehalt G, sodass mit T (m) ≤ mGBinärzähler: G = 2 Chips, Strategie:

Zählvorgang setzt genau ein Bit auf 1. Dies kostet 1 Chip

Spare anderen Chip, um Bit auf 0 zu setzenInvariante: Kontostand = Anzahl der 1-Bits





Zählvorgang setzt genau ein Bit auf 1. Dies kostet 1 ChipSpare anderen Chip, um Bit auf 0 zu setzen

Invariante: Kontostand = Anzahl der 1-Bits





Zählvorgang setzt genau ein Bit auf 1. Dies kostet 1 ChipSpare anderen Chip, um Bit auf 0 zu setzenInvariante: Kontostand = Anzahl der 1-Bits

Beispiel BinärzählerEinzelkosten



0

1

2

3

4

5

T(m

)-T(m

-1)

Operationen

Beispiel BinärzählerSummierte Kosten



0 1 2 3 4 5 6 7 8 9

10 11 12 13 14 15 16

T(m

)

Operationen

Beispiel BinärzählerSummierte Kosten ≤ 2m



0 1 2 3 4 5 6 7 8 9

10 11 12 13 14 15 16

T(m

)

Operationen

Beispiel BinärzählerT (m)/m ≤ 2



0

1

2

3

4

5

T(m

)/m

Operationen

Beispiel Hotlist-Datenstruktur



wichtige Operationen:insert(Key k , Data d)lookup(Key k ) : Datadelete(Key k )

Ziel: jede Operation in amortisiert O(√

n)

Zeit

Beispiel Hotlist-DatenstrukturLookup



wichtige Operationen:lookup(Key k ) : Datainsert(Key k , Data d)delete(Key k )

linear lookup(Key k ) in o(n)⇒ Elemente nicht komplett unsortiert

√n

n

Beispiel Hotlist-Datenstrukturinsert



insert(Key k , Data d)

Fall A: in "‘Hotlist"’ ist Platz→ nächste freie Position in "‘Hotlist"’

Laufzeit: O(1)

√n

n

Beispiel Hotlist-Datenstrukturinsert



insert(Key k , Data d)

Fall B: in "‘Hotlist"’ ist kein Platzsortiere "‘Hotlist"’merge: führe sortierte Listen zusammenk erstes Element in neuer "‘Hotlist"’

Laufzeit: O(√

n log(√

n))

+ O(n) = O(n)

√nn

n +√n

Beispiel Hotlist-DatenstrukturAmortisierung



nach Zusammenführung:√

n − 1 Positionen in der "‘Hotlist"’ frei√n insert-Operationen bis zur nächsten Zusammenführung

Zusammenführung hat Aufwand cn

Also:spare bei jeder einfachen insert-Operation c

√n an

bezahle bei der letzten Operation cn

Beispiel Hotlist-DatenstrukturLookup



lookup(Key k ) : Data

Vorgehen:

durchsuche geordnetes Array mitbinärer Suchedurchsuche "‘Hotlist"’ komplett

Laufzeit: O(log n) + O(√

n)

= O(√

n)

√n

n

Beispiel Hotlist-Datenstrukturdelete



delete(Key k ):jedes Element bekommt "‘valid"’-Bit

lookup: suche ksetze "‘valid"’-Bit auf 0

Löschoperationen "‘selten"’

Laufzeit: O(√

n)

+ O(log n) = O(√

n)

√n

n

Beispiel Hotlist-Datenstrukturdelete



delete(Key k ):bei mehr als O(1) Lösch-Opszwischen zwei Zusammenführungen

Vorgehen ähnlich zu insert

Reorganisation nach O(√

n)

Lösch-Opslookup funktioniert noch mitgleicher Laufzeit

Laufzeit: Analyse wie bei insert

√n

n

Beispiel Hotlist-Datenstrukturamortisierter Aufwand



insert(Key k ): Aufwand amortisiert in O(√

n)

lookup(Key k ): Aufwand in O(√

n)

delete(Key k ): Aufwand amortisiert in O(√

n)

Unbounded Array



Wieviele Speicherzellen brauchtein Unbounded Array gleichzeitig

für n Elemente?

Worst-Case-Betrachtunges darf eine beliebige Folge von pushBack und popBack Operationenvorausgegangen sein

a) 2n ± cb) 3n ± c

c) 4n ± cd) 6n ± c

Unbounded Array live!



1




11 5




11 51 5 6




11 51 5 6 2




11 51 5 6 21 5 6 2 11




11 51 5 6 21 5 6 2 11 4




11 51 5 6 21 5 6 2 11 4 13




11 51 5 6 21 5 6 2 11 4 13 8




11 51 5 6 21 5 6 2 11 4 13 81 5 6 2 11 4 13 8 9

Platzbedarf bei Vergrößerung: 3(n − 1) Speicherzellenfalls maximales n bekannt: bounded array oft besser⇒ Antwort b richtig?




11 51 5 6 21 5 6 2 11 4 13 81 5 6 2 11 4 13 8

Warum schrumpft das Array nicht?die Zukunft nicht bekannt (Stichwort Online-Algorithmus)Problem: erneutes pushBack→ erneutes O(n) AnwachsenProblem: Folge von n solcher popBack / pushBack→ O

(n2)

Laufzeit




11 51 5 6 21 5 6 2 11 4 13 81 5 6 2 11 4 13 8

Warum schrumpft das Array nicht?die Zukunft nicht bekannt (Stichwort Online-Algorithmus)Problem: erneutes pushBack→ erneutes O(n) AnwachsenProblem: Folge von n solcher popBack / pushBack→ O

(n2)

Laufzeitdeshalb erst bei 1/4 schrumpfen→ Ω (n) konstante Operationenseit dem letzten Anwachsen/Schrumpfen




11 51 5 6 21 5 6 2 11 4 13 81 5 6 2 11 4 13




11 51 5 6 21 5 6 2 11 4 13 81 5 6 2 11 4




11 51 5 6 21 5 6 2 11 4 13 81 5 6 2 11




11 51 5 6 21 5 6 2 11 4 13 81 5 6 2 11

Platzbedarf direkt vor Schrumpfoperation: 4(n − 1) Speicherzellen⇒ Antwort c richtig?




11 51 5 6 21 5 6 2 11 4 13 81 5 6 2 111 5 6 2

Wenn Feldkapazität 4n → schrumpfe Feld auf 2nes bleibt Platz für weitere Elementewährend Schrumpfoperation: 6n Speicherzellen gleichzeitig belegtaußer Speicherverwaltung bietet Schrumpfoperation ohne Kopieren⇒ Antwort d richtig!

Unbounded Array: Allgemeine Version



Kompromiss: im schlimmsten Fall weniger Platz, dafür langsamer?

Ja! Durch Wahl des:"‘Vergrößerungsfaktors"’ β (hier bisher immer 2)"‘Schranke"’ α (hier bisher immer 4)der verallgemeinerten Version:

realloziere βnverkleinere bei αn ≤ w ∧ n > 0

amortisierte Laufzeiten bleiben asymptotisch gleich für β > 1, α > β.größeres β, α: schneller, benötigt aber mehr Speicherplatzkleineres β, α: langsamer, benötigt aber weniger Speicherplatz






















Documents

2. Übung – Algorithmen Ialgo2.iti.kit.edu/documents/algo1-2014/uebung_02.pdf · 1 Julian Arz, Timo Bingmann, Sebastian Schlag 2. Übung – Algorithmen I Fakultät für Informatik