SS15 Algorithmen und Datenstrukturen 8. Kapitel Divide-and-Conquer-Algorithmen

SS15 Algorithmen und Datenstrukturen 8. Kapitel Divide-and-Conquer-Algorithmen Martin Dietzfelbinger Juni 2015 FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8

Ziele (des zweiten Teils) Kenntnis grundlegender Entwurfsmuster: Algorithmen-Paradigmen Kenntnis grundlegender, klassischer Algorithmen (und Datenstrukturen) Verständnis für die Bedeutung der Effizienz bei Algorithmen (Mathematisches) Nachdenken über Algorithmen: Korrektheitsanalyse: Wird das gestellte Problem gelöst? Laufzeitanalyse: Wie lange dauert es? Beherrschen von grundlegenden Techniken für diese beiden Aktivitäten. FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 1

Themen: 8. Divide-and-Conquer Multiplikation ganzer Zahlen: Algorithmus von Karatsuba Matrixmultiplikation: Algorithmus von Strassen Mergesort, exakte Analyse Rekurrenz(un)gleichungen, insbesondere: Master-Theorem Schneller randomisierter Selection-Algorithmus: Quickselect Selection in Zeit O(n) Algorithmus von BFPRT (Blum, Floyd, Pratt, Rivest, Tarjan) Schnelle Fourier-Transformation FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 2

9. Durchsuchen und Strukturanalyse von Graphen Breitensuche Erweiterte Tiefensuche (Kantenklassifikation) Kreisfreiheitstest, Finden von Kreisen Topologische Sortierung Starke Zusammenhangskomponenten Tiefensuche in ungerichteten Graphen mit Kreisfreiheitstest FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 3

10. Greedy-Strategie allgemein Teilbares Rucksackproblem Schedulingprobleme Kürzeste Wege 1: Algorithmus von Dijkstra Adressierbare Priority-Queues mittels binärer Heaps Huffman-Kodierung Set Cover FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 4

11. Minimale Spannbäume: Greedy-Strategien, Hilfsstrukturen Union-Find-Datenstruktur MST: Schnitteigenschaft MST: Algorithmus von Kruskal MST: Algorithmus von Prim Minimale Schnitte FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 5

12. Dynamische Programmierung Editierdistanz Matrix-Ketten-Multiplikation Ganzzahliges Rucksackproblem Kürzeste Wege 2: Algorithmus von Floyd-Warshall, Transitive Hülle Kürzeste Wege 3: Algorithmus von Bellman-Ford FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 6

Kapitel 8 Divide-and-Conquer (D-a-C) Ein Algorithmenparadigma. Divide-and-Conquer divide et impera teile und herrsche Schema eines D-a-C-Algorithmus A für ein Problem P: Gegeben: Instanz/Input/Eingabe x der Größe x = n. ( Trivialitätstest ) Falls n = x n 0 : löse P auf x direkt. Sonst: ( Teile ) Gewinne aus x Teilinstanzen y 1,..., y a. Rufe A rekursiv für y 1,..., y a auf, mit Lösungen r 1,..., r a. ( Kombiniere ) Gewinne aus x, y 1,..., y a, r 1,..., r a eine Lösung r des Problems P für Instanz x. FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 7

Standardbeispiele für D-a-C-Algorithmen: Mergesort, Quicksort, Binäre Suche FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 8

8.1 Multiplikation ganzer Zahlen Zahlen in Binärdarstellung. (Methoden funktionieren im Prinzip für jede beliebige Basis.) Bekannt: d c e s f Volladdierer (5 zweistellige Bitoperationen) liefert zu 3 Bits d, e, f die zwei Bits (c, s) = fulladd(d, e, f) mit c = (d e) (e f) (f d) (Übertragsbit, Carrybit) und s = d e f (Summenbit). FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 9

Bekannt: Serielle Binäraddition. Input: Binärzahlen/-strings a n 1... a 0 und b n 1... b 0 c 0 0; // Carry, Übertrag for i from 0 to n 1 do (c i+1, s i ) fulladd(a i, b i, c i ); s n c n ; Ergebnis: s n... s 0. Kosten: Nicht mehr als 5n = O(n) Bitoperationen. Bekannt: Negative Zahlen, Subtraktion. Ganze Zahlen werden als Paar (Vorzeichen, Betrag) dargestellt, z. B. 10, 1001, 101010, 11110. Additionen und Subtraktionen solcher Zahlen sind mittels Zweierkomplementdarstellung auf die Addition zurückführbar. Kosten: nicht mehr als 10n Bitoperationen. FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 10

Multiplikation zweier natürlicher Zahlen Schulmethode Faktoren: 1 0 0 1 1 0 1 1 0 0 1 1 1 0 0 1 1 0 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 1 0 + 1 0 0 1 1 0 Produkt: 1 1 1 1 0 0 1 0 0 1 0 Multiplikation = Addition von n Binärzahlen. FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 11

Allgemein: Input: Binärzahlen x = a n 1... a 0 und y = b n 1... b 0 Bilde n Binärzahlen d (0),..., d (n 1) : d (i) = (a n 1 b i )... (a 0 b i ) 0... 0 }{{} i Nullen und addiere alle diese. n 1 Additionen von Zahlen mit nicht mehr als 2n Bits: O(n 2 ) Bitoperationen. Überlege: Was ändert sich bei Ziffernsatz {0, 1,..., b 1} statt {0, 1}? Geht es billiger? FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 12

Multiplikation mit Divide-and-Conquer-Strategie: Eingabe: n-bit-binärzahlen x und y, eventuell Vorzeichen. Falls n n 0 : Benutze Schulmethode. Falls n > n 0 : ( Teile ) Setze k = n/2. Schreibe x = a n 1... a k }{{} A und y = a n 1... a k }{{} C a k 1... a 0 }{{} B a k 1... a 0 }{{} D Dann x = A 2 k + B und y = C 2 k + D. Also x y = (A 2 k +B)(C 2 k +D) = AC 2 2k +(AD+BC) 2 k +BD. FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 13

Erste Idee: Berechne rekursiv A C, A D, B C, C D, und füge die Produkte durch einige Additionen zum Resultat x y zusammen. Kosten für n-bit-zahlen (für eine Konstante c): C(n) { 1 für n = 1 4 C(n/2) + c n für n > 1. Man kann zeigen (machen wir später, Master-Theorem ): Die Anzahl der Bitoperationen ist wieder O(n 2 ), nicht besser als Schulmethode. FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 14

Wir haben: x y = A C 2 2k + (A D + B C) 2 k + B D. Trick: E := A B und F := C D (sieht sinnlos aus... ) Bemerke: E und F haben als Betrag der Differenz von zwei nichtnegativen k-bit-zahlen höchstens k Bits. Dann: E F = (A B) (C D) = A C +B D (A D + B C). Also: Eingesetzt: A D + B C = A C + B D E F. x y = A C 2 2k + (A C + B D E F ) 2 k + B D. Nur noch 3 Multiplikationen von k-bit-zahlen! FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 15

Algorithmus Ka (Algorithmus von Karatsuba) Eingabe: Zwei n-bit-zahlen x und y. if n n 0 then return SM(x, y) // Schulmethode else k := n/2 ; zerlege x = A 2 k + B und y = C 2 k + D; E := A B und F := C D; // auf n/2 Bits aufgefüllt G := Ka(A, C); // Rekursion H := Ka(B, D); // Rekursion I := Ka( E, F ); // Rekursion return G 2 2k + (G + H sign(e) sign(f ) I) 2 k + H. Dabei ist sign(a) das Vorzeichen von a. FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 16

Beispiel: Mit Dezimalzahlen, n 0 = 2. (Methode funktioniert zu jeder Basis.) In der Informatik interessante Basiszahlen: 2, 8, 10, 16, 256, 2 16, 2 32,... n = 8, x = 76490358, y = 35029630. A = 7649, B = 0358, C = 3502, D = 9630. E = A B = 7291, F = C D = 6128. Jeweils 4 Dezimalziffern. Rekursion für A C: a = 76, b = 49, c = 35, d = 02. e = a b = 27, f = c d = 33. FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 17

Weil z.b. n 0 = 2 ist, wird direkt multipliziert: g = 76 35 = 2660, h = 98, i = 27 33 = 891. 3 Multiplikationen von 2-Bit-Zahlen. Ergebnis: G = AC = 2660 10 4 +(2660+98 891) 10 2 +98 = 26786798. Analog, rekursiv: H = BD = 03447540, I = E F = 44679248. Ergebnis: x y = 26786798 10 8 + (26786798 + 03447540 ( 1) 44679248) 10 4 + 03447540 = 2679428939307540 Multiplikation mit 10 k : Anhängen von Nullen. Beim Kombinationsschritt gibt es nur Additionen! FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 18

Für Input der Größe n > n 0 müssen wir (rekursiv) a = 3 Teilprobleme lösen, für Parametergröße n/b = n/2, also b = 2: rekursiv A C, B D, E F berechnen und müssen einige Additionen und Subtraktionen von Zahlen mit maximal 2n Bits durchführen: Zusätzlich O(n) Bitoperationen. FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 19

Laufzeitanalyse: Es sei n 0 = 1 und n sei eine Zweierpotenz: n = 2 l. T Ka (n) = Anzahl der Bit-Operationen, die der Algorithmus von Karatsuba auf einer Eingabe aus zwei n-bit-zahlen macht, mit n 0 = 1. Rekurrenzungleichung: T Ka (n) { wobei c konstant ist. 1 für n = 1, 3 T Ka (n/2) + c n für n > 1, FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 20

Direkte Rechnung: T Ka (2 l ) 3 T Ka (2 l 1 ) + c 2 l 3 (3 T Ka (2 l 2 ) + c 2 l 1 ) + c 2 l = 3 2 T Ka (2 l 2 ) + c 3 2 l 1 + c 2 l 3 3 T Ka (2 l 3 ) + c 3 2 2 l 2 + c 3 2 l 1 + c 2 l. 3 l T Ka (2 0 ) + c 3 j 2 l j 0 j<l FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 21

T Ka (2 l ) 3 l T Ka (2 0 ) + c 0 j l 1 3 j 2 l j ( ) l j 2 3 l 1 + c 3 0 j l 1 ( = 3 l 1 + c 2 3 1 ) (2 3 )l 1 2 3 = 3 l (1 + 2c). Beachte: 3 l = (2 log 2 3 ) l = (2 l log 2 3 ) = (2 l ) log 2 3 = n log 2 3. Dabei: log 2 3 1,58496, also n log 2 3 viel kleiner als n 2! T Ka (n) (1 + 2c)n log 2 3 = O(n 1,585 ). FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 22

Satz 8.1.1 Beim Karatsuba-Multiplikationsalgorithmus beträgt die Anzahl der Bitoperationen und die Rechenzeit O(n log 2 3 ) = O(n 1,585 ). In der Praxis (Implementierung in Software): Nicht n 0 = 1 wählen, sondern für Zahlen einer Länge bis zur Wortgröße des Rechners (z. B. w = 32) die eingebaute Multiplikations-Hardware benutzen, d. h. mit Basis 2 w rechnen. Für Zahlen bis zu einer Länge von n 0 Worten: Schulmethode. Nur für längere Zahlen Karatsuba-Rekursion benutzen. Welches n 0 optimal ist, hängt von der Hardware und eventuell von Programmierdetails ab. (Studie hierzu: Buch von D./Mehlhorn/Sanders.) FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 23

Beispiele: 1024 Binärziffern, gut 300 Dezimalziffern. Will man mit so riesigen Zahlen rechnen? Ja! Kryptographie! Ignoriere Additionen, setze n 0 = 32. M Ka (n) = #(32-Bit-Mult. bei Karatsuba für zwei n-bit-zahlen), mit n 0 = 32. Rekurrenzgleichung: M Ka(n) = { 1 für n n 0, 3 M Ka (n/2) für n > n 0, Daraus: M Ka (2l ) = 3 l 5 M Ka (25 ) = 3 l 5. FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 24

2 10 = 1024 Binärziffern, l = 10: Karatsuba: 3 5 = 243 Multiplikationen 32 ; Schulmethode: (2 l 5 ) 2 = 1024 Multiplikationen 32. 2 15 = 32768 Binärziffern, l = 15, ca. 9900 Dezimalziffern: Karatsuba: 3 10 = 59049 Multiplikationen 32 ; Schulmethode: (2 15 5 ) 2 = 2 20 Multiplikationen 32, mehr als 1 Million! Ersparnis: Faktor 18. FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 25

Geht es noch besser? Theoretisch ja, praktisch eigentlich kaum. Mitteilung: Schönhage-Strassen (1971): Multiplikation zweier n-bit-zahlen mit O(n log n log log n) Gattern. Arnold Schönhage und Volker Strassen: Schnelle Multiplikation großer Zahlen, Computing 7, 1971, Springer Verlag, S. 281 292 Fürer (2007), De et al. (2008): Multiplikation zweier n-bit-zahlen mit O(n log n 2 log n ) Gattern. Martin Fürer: Faster integer multiplication, STOC 2007, S. 57 66. De/Saha/Kurur/Saptharishi: Fast integer multiplication using modular arithmetic. STOC 2008, S. 499 506. FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 26

Dabei ist log n definiert als die kleinste Zahl i mit log log... log n 1. }{{} i mal Also: log 2 = 1, log 4 = 2, log 16 = 3, log 65536 = 4, log (2 65536 ) = 5, log (2 265536 ) = 6. 2 265536 ist schon eine sehr große Zahl. Zahlen n mit log n > 6 kommen in der Praxis nicht vor. FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 27

Es sei R irgendein Ring. 1 8.2 Matrixmultiplikation A = (a ij ) 1 i,j n, B = (b ij ) 1 i,j n seien n n-matrizen über R. Aufgabe: Berechne C = A B, d.h. C = (c ij ) 1 i,j n mit c ij = 1 k n a ik b kj. Naive Implementierung gemäß dieser Formel kostet: n 3 Ring-Multiplikationen und n 2 (n 1) Ring-Additionen. Strassen (1969): Es geht mit weniger Multiplikationen! Ansatz: Divide-and-Conquer. FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 28

1 Man kann addieren, subtrahieren, multiplizieren. FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 29

Wir nehmen an: n = 2 l, Zweierpotenz. Eingabe: n n-matrizen A, B. Falls n n 0 : Berechne A B mit der direkten Methode. n 3 0 Multiplikationen. Falls n > n 0 : Zerlege A, B in jeweils 4 quadratische ( n 2 n 2 )-Teilmatrizen: ( ) ( ) C D G H A =, B =, E F K L Dann (leicht zu sehen): ( C G + D K C H + D L A B = E G + F K E H + F L ) FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 30

Suggeriert rekursiven Ansatz, in dem 8 Multiplikationen von ( n 2 n 2 )-Teilmatrizen durchgeführt werden. Einfache Analyse ergibt: n 3 Multiplikationen in R, kein Gewinn. (Unten: Mit Master-Theorem: O(n 3 ).) FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 31

Strassen-Trick: 7 Multiplikationen genügen. Dann: A B = P 1 = C (H L) P 5 = (C + F ) (G + L) P 2 = (C + D) L P 6 = (D F ) (K + L) P 3 = (E + F ) G P 7 = (C E) (G + H) P 4 = F (K G) ( P5 + P 4 P 2 + P 6 P 1 + P 2 P 3 + P 4 P 1 + P 5 P 3 P 7 ) Von Hand nachzukontrollieren! 18 Additionen von ( n 2 n 2 )-Matrizen. (Alternative Methode, etwas komplizierter: 15 Additionen.) FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 32

Aufwandsanalyse: Rekurrenzungleichung für die Anzahl der Operationen: T Str (n) { 1 für n = 1, 7 T Str (n/2) + c n 2 für n > 1, wobei im Fall n = 1 eine Ringmultiplikation anfällt und im Fall n > 1 neben den rekursiven Aufrufen genau 18 Additionen von ( n 2 n 2 )-Matrizen ausgeführt werden, mit Kosten 18 (n/2) 2 = 4,5 n 2. Also ist c = 4,5 eine geeignete Konstante. Nun: Rechnung für n = 2 l wie bei Karatsuba. FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 33

T Str (2 l ) 7 T Str (2 l 1 ) + c (2 2 ) l. 7 l 7 2 T Str (2 l 2 ) + c 7 (2 2 ) l 1 + c (2 2 ) l T Str (2 0 ) }{{} = 1 = 7 l + 7 l c < 7 l + 7 l c 4 7 + c 0 j l 1 0 j l 1 Wie vorher: T Str (n) = T Str (2 l ) = O(7 l ). (2 2 /7) l j (2 2 /7) l j 1 1 (4/7) < (1 + 4c/3) 7l. FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 34

Dabei: 7 l = 2 l log 2 7 = n log 2 7 mit log 2 7 2,81. FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 35

Satz 8.1.2 Beim Divide-and-Conquer-Algorithmus von Strassen für die Matrixmultiplikation beträgt die Anzahl der Ringmultiplikationen etwa n log 2 7 und die Anzahl der Ringadditionen und -subtraktionen O(n log 2 7 ). Dabei ist log 2 7 2,81. FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 36

8.3 Erinnerung: Mergesort (Alte AuD-Vorlesung bzw. hier: Kap. 6.2) Prozedur r MergeSort(a, b): A: a m b 5 7 2 3 6 3 1 5 2 3 Rekur Rekur sion sion A: a m b 2 3 5 6 7 1 2 3 3 5 Aufteilen von A[a... b] in A[a... m] und A[m + 1... b]. Rekursives Sortieren der beiden Segmente. Dann: Merge(a, m, b). FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 37

Rekurrenzgleichung für Vergleichsanzahl C(n): C(1) = 0, C(n) = C( n/2 ) + C( n/2 ) + n 1 für n 1. Gezeigt: C(n) = n log n (2 log n 1). (Mit ad-hoc-beweis.) FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 38

8.4 Das Master-Theorem Wir betrachten Rekurrenzungleichungen der folgenden Form: B(n) { g, falls n = 1 a B(n/b) + f(n), sonst. Dabei: a 1 eine ganze Zahl, b > 1 ist eine Konstante, f(n) ist eine monoton wachsende Funktion. Falls n/b keine ganze Zahl ist, sollte man sich an Stelle von B(n/b) z. B. B( n/b ) denken. FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 39

Ergibt sich bei Divide-and-Conquer-Algorithmus mit: Trivialer Basisfall (Größe 1) hat höchstens Kosten g, aus Instanz der Größe n > 1 werden a Teilinstanzen der Größe n/b (passend gerundet) gebildet ( teile ), es erfolgen a rekursive Aufrufe, und die a Lösungen werden zusammengesetzt ( kombiniere ). Kosten für das Aufspalten und das Kombinieren: f(n). O.B.d.A.: B(n) monoton wachsend. Sonst definiere: ˆB(n) = max{b(i) 1 i n}. ˆB(n) ist monoton und erfüllt die Rekurrenzungleichung. FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 40

Vereinfachende Annahmen (nicht wesentlich): n = b l. b > 1 ist ganzzahlig. Level 0: Wurzel, hat Eintrag f(n) und hat a Kinder auf Level 1. Knoten v auf Level i < l hat Eintrag f(n/b i ) und hat a Kinder auf Level i + 1. Knoten auf Level l sind Blätter, sie haben Eintrag g. FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 41

f(n) f(n) a f(n/b) f(n/b) a f(n/b) a l f(n/b 2 ) f(n/b 2 ) f(n/b 2 ) f(n/b 2 ) a 2 f(n/b 2 ) g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g a l g FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 42

Lemma 8.4.1 Wenn v ein Knoten auf Level i ist, dann gilt: B(n/b i ) Summe der Einträge im Unterbaum unter v. (Beweis durch Induktion über l i.) Also: B(n) Summe aller Einträge im Baum. FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 43

Auf Level i gibt es a i Knoten mit Eintrag f(n/b i ). Summation liefert: B(n) 0 i<l a i f(n/b i ) + a l g. Erster Term B 1 : Beitrag zu Gesamtkosten aus dem Inneren des Baums. Zweiter Term B 2 : Beitrag von den Blättern. (Algorithmisch: Die a l Basisfälle.) Leicht: B 2 (n) = a l g = (b log b a ) l g = (b l ) log b a g = n log b a g. FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 44

Erster Term: B 1 (n) = 0 i<l ai f(n/b i ). 3 Fälle, je nach Verhalten des Gesamtaufwandes a i f(n/b i ) auf Level i, für i = 0,..., l 1. Intuitiv: 1. Fall: a i f(n/b i ) wächst mit i an. 2. Fall: a i f(n/b i ) bleibt in etwa gleich über alle i. 3. Fall: a i f(n/b i ) schrumpft mit i. Genaueres folgt. FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 45

1. Fall: f(n) = O(n α ) mit b α < a. Die Beiträge aus den unteren Baumebenen (kleine Instanzen) dominieren, nicht wegen ihrer Größe, sondern wegen ihrer Anzahl. f(n) f(n/b) f(n/b) f(n/b) f(n/b 2 ) f(n/b 2 ) f(n/b 2 ) f(n/b 2 ) f(n/b 2 ) f(n/b 2 ) f(n/b 2 ) f(n/b 2 ) f(n/b 2 ) g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 46

Wir benutzen mehrfach die Summenformel für geometrische Reihen: ( ) 0 i<l q i = ql 1 q 1, für q 0, q 1. FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 47

B 1 (n) = 0 i<l = O ( 0 i<l = O ( n α = O = O ( n α = O(a l ). a i f(n/b i ) a i 0 i<l ( n α a l ( n b i ) α ) ( a b α ) i ) (a/b α ) l ) (a/b α ) 1 ) 1 (b l ) α FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 48

Also: B(n) B 1 (n) + B 2 (n) = O(a l ) = O(n log b a ). Typische Beispiele: Karatsuba-Algorithmus, Strassen-Algorithmus. FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 49

2. Fall: f(n) = O(n log b a ). f(n/b i ) wächst mit n/b i, i = l 1,..., 0, höchstens mit einer Rate, die durch das Schrumpfen der Größe der Baumebene ausgeglichen wird. Der Gesamtaufwand ist beschränkt durch den Aufwand für die Ebene direkt über den Blättern, multipliziert mit der Anzahl der Levels. FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 50

f(n) f(n/b) f(n/b) f(n/b 2 ) f(n/b 2 ) f(n/b 2 ) f(n/b 2 ) g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 51

B 1 (n) = = O = O 0 i<l a i f(n/b i ) 0 i<l 0 i<l a i = O ( l n log b a). ( n ) logb a b i a i nlog b a a i Also: B(n) B 1 (n) + B 2 (n) = O(l n log b a ) + O(n log b a ) = O((log n) n log b a ). Typische Beispiele: Mergesort, Binäre Suche. FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 52

3. Fall: f(n) = Ω(n α ), mit b α > a UND (Regularitätsbedingung: f wächst stets mit der entsprechenden Rate) Es gibt ein c < 1 mit: f(n) (a/c) f(n/b). Wenn man die Größe des Inputs von n/b auf n erhöht, wachsen die Kosten im Knoten von f(n/b) auf f(n), mindestens um den Faktor a/c > a. f(n) wächst sehr rasch mit n, so dass der Beitrag der oberen Baumebenen und insbesondere der Wurzel überwiegt. FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 53

f(n) f(n/b) f(n/b) f(n/b 2 ) f(n/b 2 ) f(n/b 2 ) f(n/b 2 ) FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 54

Aus der Regularitätsbedingung erhalten wir: f(n/b) c a f(n) ( c ) 2 f(n/b 2 ) f(n) a. f(n/b i ) ( c a ) i f(n), also: FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 55

B 1 (n) = 0 i<l 0 i<l = 0 i<l = f(n) a i f(n/b i ) a i = O(f(n)), weil 0 i<l ci = 1 cl 1 c = O(1). ( c a c i f(n) 0 i<l ) i f(n) c i FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 56

Satz 8.4.2 Das Master-Theorem (Einfache Form) { g, falls n = 1 Es gelte B(n) a B(n/b) + f(n), sonst, wobei b > 1 und a ganzzahlige Konstante sind. Dann gilt für n = b l : 1. Falls f(n) = O(n α ) mit α < log b a, dann ist B(n) = O(n log b a ). 2. Falls f(n) = O(n log b a ), dann ist B(n) = O(n log b a log n). 3. Falls f(n) = Ω(n α ) mit α > log b a und f(n) a c f(n/b), für c < 1 konstant, dann ist B(n) = O(f(n)). FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 57

Erweiterungen, dieselben Formeln gelten: Beliebige n, nicht nur n = b l. Verallgemeinerte Relation B(n) a B(n ) + f(n), n n/b + d. b > 1 nicht ganzzahlig. Analoge untere Schranken. Genaueres im Buch von D./Mehlhorn/Sanders. FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 58

8.5 Das Selektionsproblem Gegeben ist eine Folge (a 1,..., a n ) von n Objekten aus einer totalen Ordnung (D, <) (in Array oder als Liste), sowie eine Zahl k, 1 k n. O.B.d.A.: Alle Einträge verschieden. Aufgabe: Finde das Element der Folge, das Rang k hat, d. h. ein Objekt x in der Liste mit {i a i x} = k. Spezialfall: Der Median einer Folge mit n Einträgen ist das Element mit Rang n/2. (Median({2, 4, 7, 9}) = 4, Median({4, 7, 9}) = 7.) Einfache Lösung: Sortiere, mit Ergebnis (b 1,..., b n ), dann wähle x = b k. Kosten: n log n Vergleiche, Zeit O(n log n). FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 59

1 C. A. R. Hoare ( 1934), brit. Informatiker, erfand Quicksort, Quickselect & Korrektheitskalkül. I conclude that there are two ways of constructing a software design: One way is to make it so simple that there are obviously no deficiencies and the other way is to make it so complicated that there are no obvious deficiencies. The first method is far more difficult. (Dankesrede für den Turingpreis 1980) I think Quicksort is the only really interesting algorithm that I ve ever developed. Quelle: Wikipedia FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 60

Zunächst: Ein randomisierter Algorithmus für das Auswahlproblem. Quickselect (Hoare) Ansatz: Wie bei Quicksort. Gegeben: Folge (a 1,..., a n ), Zahl k, 1 k n. O.B.d.A.: Die a i sind verschieden. Falls n = 1, ist nichts zu tun. Falls n = 2, sortiere mit einem Vergleich, Ergebnis (b 1, b 2 ), gib Element b k zurück. FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 61

Falls n 3: Wähle ein Element x aus {a 1,..., a n } als partitionierendes Element zufällig. Zerlege (a 1,..., a n ) mit n 1 Vergleichen in eine Teilfolge b 1,..., b p 1, alle < x, in das Element x, und eine Teilfolge c p+1,..., c n, alle > x. 1. Fall: k = p. Das Ergebnis ist x. 2. Fall: k < p. Finde (rekursiv) in (b 1,..., b p 1 ) das Element vom Rang k. 3. Fall: k > p. Finde (rekursiv) in (c p+1,..., c n ) das Element vom Rang k p. FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 62

Prozedur quickselect(a, b, k) // Rekursive Prozedur im Quickselect-Algorithmus, 1 a < b n, a k b. // Vorbed.: Alle Einträge vom Rang < a [> b] links [rechts] von A[a..b] // Nachbed.: Eintrag vom Rang k in A[k], // kleinere links davon, größere rechts davon. (1) s ein zufälliges Element von {a,..., b}; (2) if (a < s) then vertausche A[a] und A[s]; (3) partition(a, b, p); // p: Ausgabeparameter (4) if k = p then return (5) elseif k < p then quickselect(a, p 1, k); (6) else quickselect(p + 1, b, k). Mögliche Anpassungen: (a) Sortiere z.b. mit Einfügesortieren, wenn b a sehr klein ist. (b) Anstelle von Rekursion benutze Iteration, analog zu der halbrekursiven Variante von Quicksort. FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 63

Korrektheit: Klar. Zu analysieren: (Erwartete) Rechenzeit. Klar: Die Rechenzeit ist proportional zur Anzahl C k Vergleichen. Wir berechnen den Erwartungswert E(C k ). Eingabezahlen, sortiert: b 1 < < b n. Beobachtung: Es werden niemals zwei Zahlen mehrfach verglichen. (Bei Vergleich ist eines das Pivotelement; es kommt im rekursiven Aufruf nicht mehr vor.) von FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 64

Definiere X ij = { 1, falls bi und b j verglichen werden 0, sonst. Dann gilt: C k = X ij. 1 i<j n Also (Linearität des Erwartungswertes): E(C k ) = E(X ij ). 1 i<j n Weil die X ij 0-1-wertig sind: E(X ij ) = Pr(X ij = 1) = Pr(b i und b j werden verglichen). FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 65

Was ist E(X ij ) = Pr(b i und b j werden verglichen)? Wir stellen uns den Ablauf des Algorithmus mit Auswahl von Pivotelementen und rekursiven Aufrufen für Teilarrays vor. Man beachte, dass die gebildeten Teilarrays stets einen Abschnitt {b s, b s+1,..., b t } der sortierten Folge enthalten und dass jedes Element dieser Teilfolge dieselbe Wahrscheinlichkeit hat, als Pivot gewählt zu werden. Setze I i,j = {b i,..., b j }. FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 66

1. Fall: k i < j. Solange kein Eintrag aus I k,j = {b k, b k+1,..., b j } als Pivot gewählt wird, passiert nichts bezüglich b i, b j. Es kommt auf die Position p des ersten als Pivotelement gewählten Eintrags b p in I k,j an. Wenn p < j ist, werden die Einträge in I i,j = {b i,..., b j } im Weiteren ignoriert. Wenn p = j oder p = i ist, werden b i und b j verglichen. Wenn i < p < j ist, kommt entweder b i oder b j in der Rekursion nicht mehr vor. Also: Pr(X ij = 1) = 2 j k + 1. FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 67

2. Fall: i < k < j: Es kommt darauf an, ob b i oder b j vor allen anderen Einträgen in {b i, b i+1,..., b j } Pivot wird. Also: Pr(X ij = 1) = 2 j i + 1. 3. Fall: i < j k: Es kommt darauf an, ob b i oder b j vor allen anderen Einträgen in {b i, b i+1,..., b k } Pivot wird. Also: Pr(X ij = 1) = 2 k i + 1. FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 68

Also: E(C k ) = 2 ( k i<j n 1 j k+1 + 1 i<k<j n 1 j i+1 + 1 i<j k 1 k i+1 ). Erste Summe: 1 j k + 1 = k i<j n n j=k+1 j k j k + 1 < n j=k+1 1 = n k. Dritte Summe: 1 i<j k k 1 1 k i + 1 = i=1 k 1 k i k i + 1 < i=1 1 = k 1. Beitrag dieser beiden Summen zu E(C k ) ist höchstens 2(n 1). FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 69

Die Terme der mittleren Summe S = 1 i<k<j n 1 j i + 1 stellen wir in der nachfolgenden (k 1) (n k)-matrix dar (für k n/2): 1 k+1 1 k 1 1 k+2...... n k+1 1 k+1 1 n k+2 1 1 k+2...... n k+1 1 1 n k+3... n 1 1 1 n k+2... n 2...................... 1 4 1 3 1 1 5... k+1 1 1 4... k 1 1 k+2...... n k+1 1 k+1 1 n k+2 1 1 k+2...... n k+1 1 n 1 n 1 1 n k+3 1 n k+2 FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 70

Wir betrachten die Diagonalen der Matrix. Auf jeder Diagonalen sind die Einträge konstant, und die Summe der Einträge auf jeder Diagonalen ist kleiner als 1. Es gibt genau n 2 Diagonalen, also gilt: 1 i<k<j n 1 j i + 1 < n 2. Im Falle k > n/2 funktioniert das Argument genauso; die Matrix sieht nur etwas anders aus. Man kann jedoch auch o. B. d. A. k n/2 annehmen, da aus Symmetriegründen C k = C n k+1 gilt. Zusammen: E(C k ) 4n. FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 71

Satz 8.5.1 Algorithmus Quickselect löst das Auswahlproblem und hat eine erwartete Vergleichsanzahl von 4n und eine erwartete Laufzeit von O(n). FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 72

Mitteilungen: (a) Eine genauere Analyse ergibt für α = k/n konstant eine erwartete Vergleichsanzahl von 2(1 + H(α) ln 2 + o(1))n < (3.3863 + o(1)) n. Dabei ist H(α) = α log α (1 α) log(1 α) die binäre Entropie der Wahrscheinlichkeitsverteilung (α, 1 α). H(α) liegt zwischen 0 und 1; das Maximum 1 ist bei α = 1 2, was der Suche nach dem Median entspricht. (b) Die beste Schranke für die erwartete Vergleichsanzahl bei einem Algorithmus für das Auswahlproblem, nämlich 3 2n + o(n), erreicht ein anderer randomisierter Algorithmus (siehe Vorlesung Randomisierte Algorithmen ). FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 73

Nun: Ein deterministischer Algorithmus mit Aufwand O(n). (Erfinder: M. Blum, R. W. Floyd, V. R. Pratt, R. L. Rivest, R. E. Tarjan: lauter Pioniere der Algorithmik!) Stufenweises Divide-and-Conquer. Wie bei Quickselect: Finde ein partitionierendes Element x. Verschiebe Einträge im Array, so dass alle Elemente < x links von x stehen, alle Elemente > x rechts. Lese ab, in welchem Teil das Element vom Rang k sitzt. Rufe den Algorithmus rekursiv auf diesem Teil auf. Zentrales Problem: Wie kann man deterministisch ein günstiges Element x bestimmen? FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 74

Algorithmus BFPRT(a 1,..., a n, k) //O.B.d.A.: a 1,..., a n verschieden (0) Falls k = 1 oder k = n: Bestimme Minimum/Maximum direkt. Sonst: (1) Falls n n 0 : Sortiere mit Mergesort, fertig. Sonst: (2) Teile (a 1,..., a n ) in m = n/5 Gruppen mit 4 bzw. 5 Elementen auf. (3) Bestimme in jeder Gruppe den Median (z. B. mit Mergesort). Sei (a 1,..., a m) die Liste dieser Mediane. (4) Suche mit BFPRT rekursiv den Median x von (a 1,..., a m). (5) Zerlege (a 1,..., a n ) in eine Teilfolge b 1,..., b p 1, alle < x, in das Element x, und eine Teilfolge c p+1,..., c n, alle > x. (6) Falls k = p: Rückgabe x. (7) Falls k < p: BFPRT(b 1,..., b p 1, k). // Rekursion (8) Falls k > p: BFPRT(c p+1,..., c n, k p) // Rekursion Das Pivotelement x bezeichnet man als Median der Mediane. Dieses partitionierende Element wird in den Schritten (2) (4) gefunden. FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 75

Korrektheit: Klar, durch Induktion über rekursive Aufrufe. Laufzeit: Die Laufzeit ist proportional zur Anzahl der durchgeführten Vergleiche. Wir definieren: C(n) := maximale Anzahl der Vergleiche bei Aufruf BFPRT(a 1,..., a l, k), l n, 1 k l. (Durch Maximieren über l n wird die Funktion C(n) monoton.) FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 76

Zeile (0) (Fall k {1, n}) benötigt n 1 Vergleiche, und wir sind fertig. Zeile (1) (Fall n n 0 ) benötigt höchstens n log n Vergleiche. Zeile (3): Der Median von 5 Einträgen lässt sich mit Mergesort in 8 Vergleichen bestimmen. Direktes Verfahren (Übung) erlaubt es, mit 6 Vergleichen auszukommen. Für 4 Einträge genügen 4 Vergleiche. Zeile (3) benötigt daher höchstens 6n 5 Vergleiche für die n 5 Fünfergruppen und 4n 4 Vergleiche für die n 4 Vierergruppen. Da n = 5n 5 + 4n 4, ist die Anzahl der benötigten Vergleiche nicht größer als 6n/5. FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 77

Zeile (4): Höchstens C( n/5 ) Vergleiche. Zeile (5): Exakt n 1 Vergleiche, ebenso wie bei Quickselect. Zeilen (7)/(8): Es wird nur eine dieser beiden Zeilen ausgeführt. Wir zeigen, dass in beiden Fällen die Anzahl der beteiligten Einträge nicht größer als 7n/10 + 4 ist. FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 78

1. Fall: p > k. Bei der rekursiven Suche nach dem Eintrag mit Rang k werden alle Einträge x weggelassen. Wie viele Einträge sind dies mindestens? Definiere A := {a i j : a i in Gruppe G j und a j x und a i a j }. Dann sind alle Elemente von A mindestens so groß wie x (s. Bild). Also n p + 1 A 3( m/2 + 1) 3n/10, also p 1 7n/10. Die Kosten für den rekursiven Aufruf in Zeile (7) sind also maximal C( 7n/10 ). FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 79

Spalten: Gruppen nach Umsortieren, Kriterium: a * j </=/> x Innerhalb jeder Spalte: unten kleiner als der Median, oben größer A : garantiert >= x x B : garantiert <= x FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 80

2. Fall: p < k. Bei der rekursiven Suche nach dem Eintrag mit Rang k werden alle Einträge x weggelassen. Definiere B := {a i j : a i in Gruppe G j und a j x und a i a j }. Dann sind alle Elemente von B höchstens so groß wie x (s. Bild). Weil es mindestens m/2 Gruppen G j mit a j x und maximal 4 Gruppen mit 4 Elementen gibt, folgt: p B 3 m/2 4 3n/10 4, also betrifft der rekursive Aufruf in Zeile (8) höchstens n p 7n/10 + 4 Einträge. FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 81

Die Kosten sind also maximal C( 7n/10 + 4). FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 82

Wir erhalten die folgende Rekurrenzungleichung: C(n) { n log n für n n0, C( n/5 ) + C( 7n/10 + 4) + 11n/5 für n > n 0. Dabei schätzt der Term 11n/5 die Beiträge von Zeilen (3) und (5) zusammen ab. Leider: Unser Mastertheorem nicht anwendbar. Wir lösen diese Rekurrenz direkt, indem wir eine passende Induktionsbehauptung beweisen. FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 83

Behauptung: C(n) cn für alle n und eine passende Konstante c. Die n n 0 werden erledigt, indem man c log n 0 wählt. Konkret: n 0 = 500; jedes c 9 erfüllt die Behauptung in diesem Fall. Nun sei n > n 0. Wir rechnen: C(n) C( n/5 ) + C( 7n/10 + 4) + 11n/5, I.V. c n/5 + c(7n/10 + 4) + 11n/5 cn/5 + c + 7cn/10 + 4c + 11n/5 cn + ( cn/10 + 5c + 11n/5). Entscheidend: C(n) 9 10cn + O(n). FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 84

Wir wählen c so, dass cn/10 5c + 11n/5 ist, was für c 25 und n n 0 = 500 der Fall ist (nachrechnen!). Für ein solches c lässt sich der Induktionsschritt durchführen; damit gilt die Behauptung C(n) cn für alle n. Wir haben gezeigt: Satz 8.5.2 Der BFPRT-Algorithmus löst das Auswahlproblem und hat eine Laufzeit von O(n) im schlechtesten Fall. Bemerkung: (a) Durch eine viel genauere Analyse kann die Konstante in der Vergleichsanzahl noch verbessert werden. (b) Der beste bekannte deterministische Algorithmus für das Auswahlproblem (anderer Ansatz!) benötigt (2,95 + o(1))n Vergleiche. Es ist bekannt, dass jeder deterministische Algorithmus 2n Vergleiche benötigt. FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS15 Kapitel 8 85