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

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

Ziele (des zweiten Teils) Kenntnis (und Anwendung) grundlegender Entwurfsmuster: Algorithmen-Paradigmen Kenntnis grundlegender, klassischer Algorithmen (und Datenstrukturen) und ihrer Anwendung 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 SS16 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 SS16 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 SS16 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 SS16 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 SS16 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 SS16 Kapitel 8 6

Kapitel 8 Divide-and-Conquer (D-a-C) Ein Algorithmenparadigma. Divide-and-Conquer divide et impera teile und herrsche Gegeben: Instanz/Input/Eingabe x der Größe x = n. 0. Trivialitätstest: Falls n = x n 0 : löse P auf x direkt, fertig. 1. Teile: Gewinne aus x Teilinstanzen y 1,..., y a. 2. Rekursion für Teilinstanzen: Rufe A rekursiv für y 1,..., y a auf, mit Lösungen r 1,..., r a. 3. Kombiniere: Baue aus x, y 1,..., y a, r 1,..., r a eine Lösung r des Problems P für Instanz x. Standardbeispiele für D-a-C-Algorithmen: Mergesort, Quicksort, Binäre Suche FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS16 Kapitel 8 7

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 SS16 Kapitel 8 8

Bekannt: Serielle Binäraddition. Input: Binärzahlen/-strings a n 1... a 0 und b n 1... b 0, 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: Notation als Paar (Vorzeichen, Betrag), z. B. 10, 1001, 101010, 11110. Rechnerintern: Zweierkomplementdarstellung. Addition und Subtraktion auf die Addition zurückführbar. Kosten: nicht mehr als 10n Bitoperationen. FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS16 Kapitel 8 9

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 SS16 Kapitel 8 10

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 SS16 Kapitel 8 11

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 SS16 Kapitel 8 12

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 SS16 Kapitel 8 13

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 SS16 Kapitel 8 14

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 SS16 Kapitel 8 15

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 SS16 Kapitel 8 16

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 SS16 Kapitel 8 17

Für Input der Größe n > n 0 müssen wir (rekursiv) a = 3 Teilinstanzen bearbeiten, für Parametergröße n/b = n/2, also b = 2, und im Kombinationsschritt einige Additionen und Subtraktionen von Zahlen mit maximal 2n Bits durchführen. Zusätzlich O(n) Bitoperationen. FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS16 Kapitel 8 18

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 SS16 Kapitel 8 19

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 SS16 Kapitel 8 20

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 SS16 Kapitel 8 21

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): für w = Wortlänge des Rechners (z. B. w = 32) für Operationen auf Ziffern die eingebaute Multiplikations-Hardware benutzen, d. h. mit Basis b = 2 w rechnen. Für Zahlen bis zu einer Länge von n 0 Worten: Schulmethode. (Auch in der Rekursion!) Nur für längere Zahlen D-a-C-Verfahren benutzen. Optimales n 0 : hängt von Hardware/Programmierdetails ab. Gutes n 0 : experimentell bestimmen. (Oft gut: 24 n 0 32.) (Studie hierzu: Buch von D./Mehlhorn/Sanders.) FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS16 Kapitel 8 22

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 SS16 Kapitel 8 23

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 SS16 Kapitel 8 24

8.2 Matrixmultiplikation Es sei R irgendein Ring. 1 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. 1 Man kann addieren, subtrahieren, multiplizieren. FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS16 Kapitel 8 25

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 SS16 Kapitel 8 26

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 SS16 Kapitel 8 27

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 SS16 Kapitel 8 28

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 SS16 Kapitel 8 29

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 (2 2 /7) l j (2 2 /7) l j 1 1 (4/7) < (1 + 4c/3) 7l. Wie bei Karatsuba: T Str (n) = T Str (2 l ) = O(7 l ). 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 SS16 Kapitel 8 30

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 SS16 Kapitel 8 31

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 SS16 Kapitel 8 32

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 SS16 Kapitel 8 33

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 SS16 Kapitel 8 34

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 SS16 Kapitel 8 35

Vereinfachende Annahmen (nicht wesentlich): n = b l. b > 1 ist ganzzahlig. a 1 ist ganzzahlig. Rekursionsbaum : Veranschaulicht Kostenaufteilung. 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 SS16 Kapitel 8 36

Rekursionsbaum : 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 SS16 Kapitel 8 37

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 SS16 Kapitel 8 38

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 SS16 Kapitel 8 39

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 SS16 Kapitel 8 40

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 (Breite des f(n/b i )-Knotens ist f(n/b i ).) FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS16 Kapitel 8 41

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 SS16 Kapitel 8 42

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 SS16 Kapitel 8 43

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 SS16 Kapitel 8 44

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 SS16 Kapitel 8 45

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 SS16 Kapitel 8 46

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 SS16 Kapitel 8 47

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 SS16 Kapitel 8 48

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 SS16 Kapitel 8 49

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 SS16 Kapitel 8 50

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 SS16 Kapitel 8 51

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 > 0 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 SS16 Kapitel 8 52

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, a > 0 nicht ganzzahlig. Analoge untere Schranken. Genaueres im Buch von D./Mehlhorn/Sanders. FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS16 Kapitel 8 53

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 SS16 Kapitel 8 54

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 SS16 Kapitel 8 55

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 SS16 Kapitel 8 56

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 SS16 Kapitel 8 57

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 SS16 Kapitel 8 58

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 SS16 Kapitel 8 59

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 SS16 Kapitel 8 60

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 SS16 Kapitel 8 61

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 SS16 Kapitel 8 62

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 SS16 Kapitel 8 63

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 SS16 Kapitel 8 64

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 SS16 Kapitel 8 65

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 SS16 Kapitel 8 66

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 SS16 Kapitel 8 67

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 SS16 Kapitel 8 68

BFPRT-Algorithmus im SS 2016 nicht prüfungsrelevant! 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. Zentral: Deterministisch ein günstiges Element x bestimmen. FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS16 Kapitel 8 69

FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS16 Kapitel 8 70

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 FG KTuEA, partitionierende TU Ilmenau Algorithmen Element und Datenstrukturen wird in SS16 den Kapitel Schritten 8 (2) (4) gefunden. 71

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 SS16 Kapitel 8 72

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): Median von 5 Einträgen: mit Mergesort in 8 Vergleichen. Direktes Verfahren (Übung): 6 Vergleiche. Für 4 Einträge genügen 4 Vergleiche. Zeile (3) benötigt daher 6n 5 Vergleiche für die n 5 Fünfergruppen und 4n 4 Vergleiche für die n 4 4 Vierergruppen. Da n = 5n 5 + 4n 4, ist dies zusammen 6n/5. FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS16 Kapitel 8 73

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 SS16 Kapitel 8 74

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 SS16 Kapitel 8 75

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 SS16 Kapitel 8 76

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. Die Kosten sind also maximal C( 7n/10 + 4). FG KTuEA, TU Ilmenau Algorithmen und Datenstrukturen SS16 Kapitel 8 77

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 SS16 Kapitel 8 78

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 SS16 Kapitel 8 79

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 SS16 Kapitel 8 80