Effiziente Algorithmen

Transkript

1 Effiziente Algorithmen Vorüberlegungen und Divide-and-Conquer-Algorithmen Vorlesender: Martin Aumüller (nach Folien von Prof. Martin Dietzfelbinger) April 2012 FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

2 Organisatorisches Hörer: Informatikstudierende (Bachelor) im 4. Semester, Mathematikstudierende, andere Fächer bei Bedarf Material: Eigene Mitschrift Folienkopien, Übungsblätter auf der folgenden Webseite: Zugang über die Institutsseite. Stoff: Vorlesung + Übungsaufgaben. FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

3 Organisatorisches Zur Arbeitsweise: Der Stoff ist zu kompliziert und zu umfangreich, um durch reines Zuhören verstanden zu werden. Regelmäßig Vorlesung nacharbeiten. Semesterbegleitend! Begleitend Bücher ansehen. Übungsblätter drucken, lesen, zur Übung mitbringen, vorher Lösung ausdenken, Lösungsweg aufschreiben, an Lösungen mitarbeiten, Lösungen vortragen. Regelmäßig Übungen nacharbeiten. Semesterbegleitend! Bei Verständnisproblemen frühzeitig fragen! FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

4 Organisatorisches Zeitaufwand? Leistungspunkte: 4 LP Entspricht 120 Zeitstunden. Vorlesungszeit: 15 Wochen. 6 Stunden pro Woche Davon: in Vorlesung/Übung Zeitaufwand: Zeitstunden pro Woche neben Vorlesung + Übung! ergibt: 90 Stunden plus 30 Stunden Prüfungsvorbereitung! FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

5 Organisatorisches Literaturvorschläge: T. H. Cormen, C. E. Leiserson, R. L. Rivest, C. Stein, Introduction to Algorithms, 2nd ed., MIT Press, 2001 (auch auf deutsch bei Oldenbourg) S. Dasgupta, C. Papadimitriou, U. Vazirani, Algorithms, McGraw-Hill, 2007 V. Heun, Grundlegende Algorithmen, 2. Auflage, Vieweg, 2003 J. Kleinberg, E. Tardos, Algorithm Design, Pearson Education, 2005 K. Mehlhorn, P. Sanders, Algorithms and Data Structures: The Basic Toolbox, Springer-Verlag, 2008 FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

6 Organisatorisches Literaturvorschläge: T. Ottmann, P. Widmayer, Algorithmen und Datenstrukturen, Spektrum Akademischer Verlag, 2002 U. Schöning, Algorithmik, Spektrum Akademischer Verlag, 2001 R. Sedgewick, Algorithms, Addison-Wesley, 2002 (auch C-, C++, Java-Versionen, auch auf deutsch bei Pearson) R. Sedgewick, Algorithms, Part 5: Graph Algorithms, Addison-Wesley, 2003 Vorlesung folgt eigenem Plan, nicht direkt einem Buch. FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

7 Organisatorisches Übungen: Dienstag (U), 15:00-16:30, HU 011 Mittwoch (U), 11:00-12:30, HU 011 Mittwoch (U), 13:00-14:30, HU 204 Übungen beginnen am Prüfung: (bei Prof. Dietzfelbinger) (Bachelor Informatik) Juli Sept. 2012, Min. mündlich (andere) nach Vereinbarung, mündlich. Bonuspunkte: Korrektes Vorrechnen einer (markierten) Übungsaufgabe mit vorheriger schriftlicher Abgabe ˆ= Notenverbesserung um 0,3 (maximal 2 pro Teilnehmer/in, nicht automatisch von 5,0 auf 4,0). FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

8 Organisatorisches Themen: 1. Divide-and-Conquer Multiplikation ganzer Zahlen: Algorithmus von Karatsuba Matrixmultiplikation: Algorithmus von Strassen Mergesort, exakte Analyse Rekurrenz(un)gleichungen, insbesondere: Master-Theorem Quicksort, neue Analyse Selection in Zeit O(n) Algorithmus von BFPRT (Blum, Floyd, Pratt, Rivest, Tarjan) Schneller Selection-Algorithmus: Randomisiert Schnelle Fourier-Transformation FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

9 Organisatorisches 2. Durchsuchen und Strukturanalyse von Graphen Erinnerung: Breitensuche Erweiterte Tiefensuche (Kantenklassifikation) Kreisfreiheitstest, Finden von Kreisen Topologische Sortierung Starke Zusammenhangskomponenten Tiefensuche in ungerichteten Graphen mit Kreisfreiheitstest FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

10 Organisatorisches 3. 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 Effiziente Algorithmen Sommersemester

11 Organisatorisches 4. 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 Effiziente Algorithmen Sommersemester

12 Organisatorisches 5. 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 Effiziente Algorithmen Sommersemester

13 Kapitel 1 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 ist Instanz/Input/Eingabe x der Größe x = n. Falls n = x n 0 (Größenschranke): löse P auf x direkt. Sonst: Gewinne aus x Teilinstanzen y 1,..., y a ( teile ). Rufe A rekursiv für y 1,..., y a auf, mit Lösungen r 1,..., r a. Gewinne aus x, y 1,..., y a, r 1,..., r a eine Lösung r des Problems P für Instanz x ( kombiniere ). FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

14 Standardbeispiele aus AuD für D-a-C-Algorithmen: Mergesort Quicksort Binäre Suche (Details in der AuD-Vorlesung.) FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

15 Multiplikation ganzer Zahlen 1.1 Multiplikation ganzer Zahlen Zahlen in Binärdarstellung. (Methoden funktionieren im Prinzip für jede beliebige Basis.) Bekannt: Volladdierer (5 Bitoperationen) liefert zu 3 Bits d, e, f die zwei Bits (s, c) = fulladd(d, e, f ) mit s = d e f (Summenbit) und c = (d e) (e f ) (f d) (Übertragsbit, Carry). FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

16 Multiplikation ganzer Zahlen 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 (s i, c i+1 ) 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, , Additionen und Subtraktionen solcher Zahlen mit der Zweierkomplementdarstellung auf die Addition zurückführbar. Kosten: nicht mehr als 6n Bitoperationen. FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

17 Multiplikation ganzer Zahlen Multiplikation zweier natürlicher Zahlen Schulmethode : Überträge: Produkt: FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

18 Multiplikation ganzer Zahlen Allgemein: Input: Binärzahlen/-strings a n 1... a 0 und 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 ) }{{} i Nullen und addiere alle diese. n 1 Additionen von Zahlen mit nicht mehr als 2n Bits: O(n 2 ) Bitoperationen. Geht es billiger? FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

19 Multiplikation ganzer Zahlen 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 : Setze k = n/2. Schreibe x = x n 1... x k } {{ } A und y = y n 1... y k } {{ } C x k 1... x 0 } {{ } B y k 1... y 0 } {{ } D Teile! Dann x = A 2 k + B und y = C 2 k + D. x y = (A 2 k + B)(C 2 k + D) = AC 2 2k + (AD + BC) 2 k + BD. FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

20 Multiplikation ganzer Zahlen Erste Idee: Berechne rekursiv AC, AD, BC, BD, 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. (1) Man kann zeigen (später: Master-Theorem ): Die Anzahl der Bitoperationen ist wieder Θ(n 2 ), nicht besser als Schulmethode. FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

21 Multiplikation ganzer Zahlen x y = (A 2 k + B)(C 2 k + D) = AC 2 2k + (AD + BC) 2 k + BD. 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. Nun: E F = (A B)(C D) = AC + BD (AD + BC). Also: AD + BC = AC + BD EF. x y = AC 2 2k + (AC + BD EF ) 2 k + BD. FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

22 Multiplikation ganzer Zahlen 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 Effiziente Algorithmen Sommersemester

23 Multiplikation ganzer Zahlen 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 = , y = A = 7649, B = 0358, C = 3502, D = E = A B = 7291, F = C D = 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 Effiziente Algorithmen Sommersemester

24 Multiplikation ganzer Zahlen Weil z.b. n 0 = 2 ist, wird direkt multipliziert: g = = 2660, h = 98, i = = Multiplikationen von 2-Bit-Zahlen. Ergebnis: G = AC = ( ) = Analog, rekursiv: H = BD = , I = E F = Ergebnis: x y = ( ( 1) ) = Beim Kombinationsschritt gibt es nur Additionen! FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

25 Multiplikation ganzer Zahlen Für Input der Größe n > n 0 müssen wir (rekursiv) a = 3 Teilprobleme für die Parametergröße n/b = n/2, also b = 2, lösen: rekursiv AC, BD, EF 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 Effiziente Algorithmen Sommersemester

26 Multiplikation ganzer Zahlen Einfachst-Analyse: Es sei n 0 = 1 und n sei eine Zweierpotenz: n = 2 l. M Ka (n) = Anzahl der Bit-Multiplikationen ( -Operationen). T Ka (n) = Anzahl der Bit-Operationen. T Ka (n 0 ) = 1 und T Ka (n) 3T Ka (n/2) + cn, wobei c konstant ist. M Ka (n 0 ) = 1 und M Ka (n) = 3M Ka (n/2). Die zweite Rekurrenz-Gleichung ist einfacher. Achtung: Bitmultiplikationen gibt es nur auf dem untersten Rekursionslevel. FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

27 Multiplikation ganzer Zahlen M Ka (n 0 ) = 1 und M Ka (n) = 3 M Ka (n/2). M Ka (2 l ) = 3 M Ka (2 l 1 ) = 3 2 M Ka (2 l 2 ) = 3 3 M Ka (2 l 3 ). = 3 l M Ka (2 l l ) = 3 l M Ka (n 0 ) = 3 l. Beachte: 3 l = (2 log 2 3 ) l = (2 l log 2 3 ) = (2 l ) log 2 3 = n log 2 3. Dabei ist log 2 3 1, Deutlich kleiner als n 2! FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

28 Multiplikation ganzer Zahlen T Ka (n 0 ) = 1 und T Ka (n) 3T Ka (n/2) + cn, wobei c konstant. 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 l 2 + c 3 2 l 1 + c 2 l. 3 l T Ka (2 0 ) + c 0 j<l 3 j 2 l j FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

29 Multiplikation ganzer Zahlen T Ka (2 l ) 3 l T Ka (2 0 ) + c 0 j l 1 3 j 2 l j ( ) 2 l j 3 l 1 + c 3 0 j l 1 ( = 3 l 1 + c ( ) 2 3 )l ( ) < 3 l 1 + c = 3 l (1 + 2c). Also: T (n) (1 + 2c)n log 2 3 = O(n 1,585 ). FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

30 Multiplikation ganzer Zahlen Satz 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. FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

31 Multiplikation ganzer Zahlen Praxisbeispiel: GMP (GNU Multiple Precision Arithmetic Library) Nutzt 4 verschiedene Stufen: 1 Schulmethode 2 Karatsuba 3 TOOM33 (Knuth Abschnitt 4.3.3) 4 FFT-basierter Algorithmus Wechsel der Methode, sobald Anzahl Maschinenwörtern der Eingabe unter bestimmte Grenze sinkt. Grenzen stark abhängig von der genutzten Architektur! Atom-Prozessoren (x86) 1 Karatsuba: 10 #Wörter 65 2 TOOM33: 66 #Wörter FFT: 3456 Wörter FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

32 Multiplikation ganzer Zahlen Praxisbeispiel: GMP (GNU Multiple Precision Arithmetic Library) Nutzt 4 verschiedene Stufen: 1 Schulmethode 2 Karatsuba 3 TOOM33 (Knuth Abschnitt 4.3.3) 4 FFT-basierter Algorithmus Wechsel der Methode, sobald Anzahl Maschinenwörtern der Eingabe unter bestimmte Grenze sinkt. Grenzen stark abhängig von der genutzten Architektur! Core2-Prozessoren (x86 64) 1 Karatsuba: 23 #Wörter 64 2 TOOM33: 65 #Wörter FFT: 4736 Wörter FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

33 Multiplikation ganzer Zahlen Beispiele: Zahlen mit 1024 Binärziffern haben gut 300 Dezimalziffern. (Will man mit so riesigen Zahlen rechnen?) Ja! Kryptographie! Anzahl der Multiplikationen von 32-Bit-Zahlen: M Ka (210 ) = 3 l 5 M Ka (25 ) = 3 5 = 243. Schulmethode: (2 l 5 ) 2 = 1024 Multiplikationen. Zahlen mit Binärziffern haben etwa 9900 Dezimalziffern. M Ka (215 ) = M Ka (25 ) = 3 10 = Schulmethode: ( ) 2 = 2 20 Multiplikationen, mehr als 1 Million! Ersparnis: Faktor 18. FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

34 Multiplikation ganzer Zahlen 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 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 De/Saha/Kurur/Saptharishi: Fast integer multiplication using modular arithmetic. STOC 2008, S FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

35 Multiplikation ganzer Zahlen 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 = 4, log ( ) = 5, log ( ) = 6, und ist schon eine sehr große Zahl. (Leider sind beide Algorithmen in der Praxis nicht so sehr hilfreich.) FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

36 Matrixmultiplikation Es sei R irgendein Ring 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. 1 Man kann addieren, subtrahieren, multiplizieren. FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

37 Matrixmultiplikation 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: A = Dann (leicht zu sehen): ( C D E F A B = ) ( G H, B = K L ( CG + DK CH + DL EG + FK EH + FL ) ) FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

38 Matrixmultiplikation 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 Effiziente Algorithmen Sommersemester

39 Matrixmultiplikation Strassen-Trick: 7 Multiplikationen genügen. Dann: AB = Von Hand nachzukontrollieren! 18 Additionen. 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 (Alternative Methode, etwas komplizierter: 15 Additionen.) ) FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

40 Matrixmultiplikation Aufwandsanalyse (einfachst): Für n 0 = 1, M(n) = Anzahl der Ringmultiplikationen. (Nur im Basisfall der Rekursion!) M(1) = 1; M(n) = 7M(n/2) für n > 1. Für n = 2 l : M(2 l ) = 7M(2 l 1 ) =... = 7 l M(1) = 7 l. 7 l = 2 l log 2 7 = n log 2 7 mit log 2 7 2,81. Aufwandsanalyse (etwas komplizierter): Ringadditionen. A(1) = 0; A(n) 7A(n/2) + cn 2 (für eine Konstante c). Rechnung wie bei Zahlen-Multiplikation ergibt: FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

41 Matrixmultiplikation A(2 l ) 7 A(2 l 1 ) + c (2 2 ) l 7 2 A(2 l 2 ) + c 7 (2 2 ) l 1 + c (2 2 ) l. 7 l = 7 l c A(2 0 ) }{{} = 0 + c 0 j l 1 0 j l 1 (2 2 /7) l j (2 2 /7) l j = 7 l c (4/7)l 1 (4/7) < 7l c Wieder O(n log 2 7 )! Alternative: Master-Theorem. = (4c/3) 7 l. FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

42 Mergesort 1.3 Erinnerung: Mergesort Um n Zahlen/Objekte a 1,..., a n zu sortieren, geht der Mergesort-Algorithmus so vor: Falls n n 0 : Sortiere mit einem naiven Algorithmus (z. B. Insertion Sort). Sonst: k := n/2. Sortiere a 1,..., a k (erste Hälfte) rekursiv, Ergebnis b 1,..., b k ; sortiere a k+1,..., a n (zweite Hälfte) rekursiv, Ergebnis b k+1,..., b n. Mische die Folgen b 1,..., b k und b k+1,..., b n zu einer sortierten Folge zusammen Reißverschlussverfahren Aufwand: n 1 Vergleiche. FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

43 Mergesort Analyse über Rekurrenzungleichungen : Wir zählen nur Vergleiche. C(n) = Anzahl der Vergleiche beim Sortieren von n Eingaben, schlechtester Fall. C(1) = 0, C(2) = 1, C(3) = 3. C(n) = C( n/2 ) + C( n/2 ) + n 1. Behauptung: C(n) = n log n (2 log n 1). n C(n) Beweis: Tafel. FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

44 Mergesort Satz Für die Vergleichsanzahl im schlechtesten Fall bei Mergesort gilt: Beweis: Tafel. C(n) n log n. FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

45 Master-Theorem 1.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 Effiziente Algorithmen Sommersemester

46 Master-Theorem 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 ( divide ) a Teilinstanzen der Größe n/b (passend gerundet) gebildet, es erfolgen a rekursive Aufrufe, und die a Lösungen werden kombiniert. 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 Effiziente Algorithmen Sommersemester

47 Master-Theorem 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 Effiziente Algorithmen Sommersemester

48 Master-Theorem 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 Effiziente Algorithmen Sommersemester

49 Master-Theorem Lemma 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 Effiziente Algorithmen Sommersemester

50 Master-Theorem 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 Effiziente Algorithmen Sommersemester

51 Master-Theorem 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 Effiziente Algorithmen Sommersemester

52 Master-Theorem 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 Effiziente Algorithmen Sommersemester

53 Master-Theorem Wir benutzen immer 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 Effiziente Algorithmen Sommersemester

54 Master-Theorem B 1 (n) = 0 i<l = O ( a i f (n/b i ) 0 i<l a i ( n b i ) α ) = O ( ( a ) i n α ) b α 0 i<l ( = O n α (a/b α ) l ) (a/b α ) 1 ( ) = O n α a l 1 (b l ) α = O(a l ). Also: B(n) B 1 (n) + B 2 (n) = O(a l ) = O(n log b a ). FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

55 Master-Theorem 1. Fall: f (n) = O(n α ) mit b α < a. Typische Beispiele: Karatsuba-Algorithmus, Strassen-Algorithmus. FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

56 Master-Theorem 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. 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 Effiziente Algorithmen Sommersemester

57 Master-Theorem B 1 (n) = = O = O = O 0 i<l a i f (n/b i ) 0 i<l a i ( n ) logb a b i a i nlog b a a i 0 i<l ( l n log a) b. 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 Effiziente Algorithmen Sommersemester

58 Master-Theorem 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 Effiziente Algorithmen Sommersemester

59 Master-Theorem 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 Effiziente Algorithmen Sommersemester

60 Master-Theorem Aus der Regularitätsbedingung gewinnen 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 Effiziente Algorithmen Sommersemester

61 Master-Theorem B 1 (n) = a i f (n/b i ) 0 i<l ( c ) i a i f (n) a 0 i<l = 0 i<l = f (n) c i f (n) 0 i<l = O(f (n)), c i weil 0 i<l ci = 1 cl 1 c = O(1). FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

62 Master-Theorem Satz (Das Master-Theorem) { 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 konstant, dann ist B(n) = O(f (n)). f (n/b), für c < 1 FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

63 Master-Theorem Erweiterungen: Dieselben Formeln gelten für: 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 Cormen, Leiserson, Rivest und Stein. FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

64 Quicksort 1.5 Quicksort (Hoare 1 ) Neue Analyse Input: Folge/Array (a 1,..., a n ). Falls n = 1, Ausgabe (a 1 ). Falls n = 2, sortiere mit einem Vergleich. Sonst: Wähle Element x {a 1,..., a n } als Pivotelement oder partitionierendes Element. (Z.B.: x = a 1 oder x = a i mit i zufällig.) 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. Sortiere diese beiden Folgen rekursiv, Ergebnis (d 1,..., d p 1 ) und (e p+1,..., e n ). Ausgabe: Folge/Array (d 1,..., d p 1, x, e p+1,..., e n ). FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

65 Quicksort 1 C. A. R. Hoare ( 1934), brit. Informatiker, erfand Quicksort & 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. FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

66 Quicksort Analyse: Wir nehmen an, alle Schlüssel sind verschieden. Wir wählen immer das erste Element als Pivotelement betrachten also deterministisches Quicksort. Weiter nehmen wir an, jede der n! Anordnungen sind gleich wahrscheinlich (Wahrscheinlichkeit 1/n!), und berechnen die erwartete Anzahl A(n) von Vergleichen. Falls n 1: kein Vergleich. Falls n = 2: 1 Vergleich. Sonst: FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

67 Quicksort Es seien b 1 < < b n die Eingabe-Elemente in sortierter Reihenfolge. Es ist klar, dass b i und b j maximal einmal miteinander verglichen werden. (Wenn b i und b j verglichen werden, ist eines der beiden Pivotelement und wird nie mehr mit etwas anderem verglichen.) FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

68 Quicksort C := Gesamtanzahl der Vergleiche. (Zufallsvariable, abhängig von der zufälligen Anordnung am Anfang.) Sei C = X ij, 1 i<j n wobei X ij = { 1, falls bi und b j verglichen werden 0, sonst. FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

69 Quicksort Daraus: E(C) = 1 i<j n E(X ij ) = 1 i<j n Pr(X ij = 1). (Das folgt aus der Linearität des Erwartungswertes, normalerweise geschrieben als E(X + Y ) = E(X ) + E(Y ).) Was ist Pr(X ij = 1) = Pr(b i und b j werden verglichen)? Wir beobachten den Algorithmus. Klar: Im Zuge der Rekursion werden durch Aufspalten immer kleinere Teillisten gebildet. Solange kein Element von I ij = {b i, b i+1,..., b j } Pivotelement wird, landen alle Elemente von I ij immer in derselben Teilliste (alle größer als Pivot oder alle kleiner als Pivot). FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

70 Quicksort In dem Moment, in dem zum ersten Mal ein Element von I ij partitionierendes Element wird, fällt die Entscheidung: Wenn dies b i oder b j ist, werden b i und b j verglichen. Wenn dies ein Element von {b i+1,..., b j 1 } ist, nicht (jetzt nicht, aber auch nicht später, da sie in verschiedenen Teillisten landen). Weil alle Elemente in I ij die gleiche Wahrscheinlichkeit haben, zuerst als Pivotelement gewählt zu werden, gilt Pr(b i und b j werden verglichen) = 2 I ij = 2 j i + 1. Also: E(C) = 1 i<j n 2 j i + 1. FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

71 Quicksort 1 i<j n 2 j i + 1 = 1 i n i<j n = j i i n 2 k n i+1 1 i n 2 k n = 2 n (H n 1) 2 n ln n 1 k = (2 ln 2) n log n < 1,3863n log n. 1 k FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

72 Quicksort Dabei ist H n = n [ln n + 1 2, ln n + 1] (n-te harmonische Zahl). Satz Die durchschnittliche Anzahl von Vergleichen von Quicksort auf einer Eingabe aus n verschiedenen Zahlen, die zufällig angeordnet ist, ist höchstens 2 n (H n 1) < 1,3863n log n. Für die, die es genau wissen wollen: E(C) = 2(n + 1)H n 4n = (2 log 2 e)n log n Θ(n). FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

73 Quicksort Variation: Randomisiertes Quicksort. Das Pivotelement wird jeweils zufällig gewählt. In diesem Fall ist die gleiche Analyse anwendbar. Aber: Es gibt keine worst-case-inputs mehr. Satz Wenn man das Pivot-Element stets zufällig wählt, ist auf einer beliebigen, festen Eingabe aus n verschiedenen Zahlen die erwartete Anzahl von Vergleichen, die Quicksort ausführt, höchstens 2 n (H n 1) < 1,3863n log n. (Siehe hierzu: Randomisierte Algorithmen.) FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

74 Selektionsproblem 1.6 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 ), nun wähle x = b k. Kosten: n log n Vergleiche, Zeit O(n log n). FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

75 Selektionsproblem 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 Effiziente Algorithmen Sommersemester

76 Selektionsproblem 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 Effiziente Algorithmen Sommersemester

77 Selektionsproblem Korrektheit: Klar. Zu analysieren: (Erwartete) Rechenzeit. Wir analysieren die erwartete Anzahl von Vergleichen. Vorgehen: Wie bei Quicksort. Wieder ist die erwartete Anzahl von Vergleichen entscheidend. Eingabezahlen, sortiert: b 1 < < b n. C k = 1 i<j n X ij, wobei X ij = { 1, falls bi und b j verglichen werden 0, sonst. FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

78 Selektionsproblem Was ist E(X ij ) = Pr(X ij = 1) = Pr(b i und b j werden verglichen)? 1. Fall: k i < j: Es kommt darauf an, ob b i oder b j vor allen anderen Einträgen in {b k,..., b j } Pivot werden. Pr(X ij = 1) = 2 j k Fall: i < k < j: Es kommt darauf an, ob b i oder b j vor allen anderen Einträgen in {b i,..., b j } Pivot werden. Pr(X ij = 1) = 2 j i Fall: i < j k: Es kommt darauf an, ob b i oder b j vor allen anderen Einträgen in {b i,..., b k } Pivot werden. Pr(X ij = 1) = 2 k i+1. FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

79 Selektionsproblem Also: E(C k ) = 2 ( k i<j n 1 j k i<k<j n 1 j i i<j k 1 k i+1 ). Erste und dritte Summe lassen sich leicht als n k bzw. k 1 abschätzen (Übung!). Zusammen: 2(n 1). In der Übung zeigen wir: Zusammen: E(C k ) 4n. 1 i<k<j n 1 j i+1 n. FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

80 Selektionsproblem Es gilt: k i<j n 1 j k + 1 = n j=k+1 j k j k + 1 < n j=k+1 1 = n k. Weiterhin gilt: 1 i<j k k 1 1 k i + 1 = i=1 k 1 k i k i + 1 < i=1 1 = k 1. Die Terme der Summe 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): FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

81 Selektionsproblem 1 i<k<j n 1 j i k+1 1 k k n k+1 1 k+1. 1 n k k n k n k+3... n n k+2... n k k 1 1 k n k+1 1 k+1 1 n k k n k+1 1 n 1 n 1. 1 n k+3 1 n k+2 FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

82 Selektionsproblem Wir summieren entlang der Diagonalen. Auffällig: Die Summe der Elemente auf einer Diagonalen ist jeweils kleiner als 1. Es gibt maximal k 2 + n k Diagonalen, also gilt: 1 i<k<j n 1 j i + 1 < n 2. Anmerkung: Im Falle k > n/2 gilt das hier gebrachte Argument nachwievor, die Matrix sieht schematisch aber etwas anders aus. Aus Symmetriegründen (C k = C n k+1 ) kann man jedoch auch ohne Beschränkung der Allgemeinheit k n/2 annehmen. FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

83 Selektionsproblem Satz Der Algorithmus Quickselect löst das Auswahlproblem und hat eine erwartete Vergleichsanzahl von 4n und eine erwartete Laufzeit von O(n). FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

84 Selektionsproblem Mitteilung: (a) Eine genauere Analyse ergibt für α = k/n konstant eine erwartete Vergleichsanzahl von 2(1 + H(α) ln 2 + o(1))n < ( o(1)) n. Dabei ist H(α) = α log α (1 α) log(1 α) die binäre Entropie. Sie liegt zwischen 0 und 1; das Maximum 1 ist bei α = 1 2 nach dem Median entspricht., was der Suche (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 Effiziente Algorithmen Sommersemester

85 Selektionsproblem Nun: Ziel: 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!) FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

86 Selektionsproblem Ansatz: Wie bei Quickselect: Finde ein partitionierendes Element x. Verschiebe, so dass alle Elemente < x links von x stehen, alle Elemente > x rechts. Bestimme, in welchem Teil das gesuchte Element vom Rang k ist. Rufe den Algorithmus rekursiv auf diesem Teil auf. Zentrales Problem Wie kann man deterministisch ein günstiges Element x bestimmen? FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

87 Selektionsproblem Algorithmus BFPRT(a 1,..., a n, k) 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 (Bsp: Mergesort). Sei (a 1,..., a m) die Liste dieser Mediane. 4 Suche rekursiv mittels BFPRT nach dem 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). 8 Falls k > p: BFPRT(c p+1,..., c n, k p). In der Literatur bezeichnet man x als Median der Mediane. Das Finden eines partitionierenden Elements erfolgt in den Schritten 2 4. FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

88 Selektionsproblem Korrektheit: Klar. Laufzeit: Wir müssen zeigen, dass die Teilprobleme in den Schritten 4, 7 bzw. 8 um einen genügend großen Faktor kleiner sind als das Ausgangsproblem. FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

89 Selektionsproblem Wieviele Elemente sind garantiert maximal so groß wie x? x Abbildung : Mediane der Gruppen blau gefärbt. Mediane (mit deren Gruppen) aufsteigend sortiert. Pfeilspitzen deuten auf das jeweils größere Element. Rot: Alle Elemente, die maximal so groß wie x sind. FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

90 Selektionsproblem Effekt: m/2 + 1 der Mediane sind maximal so groß wie x. Die Gruppen dieser Mediane beinhalten zusätzlich noch jeweils 2 kleinere Elemente. p 3 ( m/2 + 1) 3n/10. FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

91 Selektionsproblem Wieviele Elemente sind mindestens so groß wie x? x Abbildung : Mediane der Gruppen blau gefärbt. Mediane (mit deren Gruppen) aufsteigend sortiert. Pfeilspitzen deuten auf das jeweils größere Element. Rot: Alle Elemente, die mindestens so groß wie x sind. FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

92 Selektionsproblem Effekt: m/2 der Mediane sind mindestens so groß wie x. Die Gruppen dieser Mediane beinhalten zusätzlich noch jeweils 2 größere Elemente. (Sonderfall: In 4-er Gruppen gibt es jeweils nur ein größeres Element. Davon gibt es aber nur maximal 4!) Es gilt p n (3 ( m/2 ) 4) 7n/ Also betrachten wir im rekursiven Aufruf maximal 7n/ Elemente! FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

93 Selektionsproblem Weitere Laufzeitbetrachtungen: Mediansuche in Schritt 3: 8 Vergleiche mit Mergesort, 6 Vergleiche möglich (siehe Übung.) Rekursive Mediansuche in Schritt 4: Rekursiver Aufruf mit Liste von m = n/5 Elementen. Aufspalten in Schritt 5: Kosten n 1 Vergleiche. Kosten für Schritt 3 und 5: 6 n/5 + n 1 < 11 5 n < 11 5 n + 4 FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

94 Selektionsproblem Laufzeitanalyse: Die Laufzeit ist proportional zur Anzahl der durchgeführten Vergleiche. Wir definieren: C(n) := maximale Anzahl der Vergleiche bei Aufruf BFPRT(a 1,..., a p, k), p n, 1 k p. (Durch das p n wird die Funktion C(n) monoton.) Die Anzahl C(n) der Vergleiche im Algorithmus gehorcht der folgenden Rekurrenzungleichung C(n) n log n, für n n 0 ; C(n) C( n/5 ) + C(7n/10 + 4) + 11n/5 + 4, für n > n 0. FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

95 Selektionsproblem Wir behaupten: 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 + 4, Entscheidend: C(n) 9 10cn + O(n). I.V. c n/5 + c(7n/10 + 4) + 11n/5 + 4 cn/5 + c + 7cn/10 + 4c + 11n/5 + 4 cn + ( cn/10 + 5c + 11n/5 + 4). FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

96 Selektionsproblem Wir wählen c so, dass cn/10 5c + 11n/5 + 4 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 Der BFPRT-Algorithmus löst das Auswahlproblem und hat eine Laufzeit von O(n) im schlechtesten Fall. Bemerkung: Durch eine viel genauere Analyse kann die Konstante in der Vergleichsanzahl noch verbessert werden. Der beste bekannte deterministische Algorithmus (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 Effiziente Algorithmen Sommersemester

97 FFT 1.7 Die schnelle Fourier-Transformation (FFT) Polynom in Koeffizientendarstellung: A(x) = a 0 + a 1 x + a 2 x a n 1 x n 1 = 0 i n 1 a i x i, mit a 0,..., a n 1 Zahlenbereich Z oder R oder C. Für die Durchführung benötigen wir komplexe Zahlen. Am Schluss wird eine Alternative skizziert, die man für Berechnungen über Z benutzen kann, ohne dabei zu komplexen Zahlen überzugehen. FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

98 FFT Aufgabe: Gegeben zwei Polynome A(x) und B(x), als A(x) = a i x i und B(x) = b j x j, 0 i n 1 berechne das Polynomprodukt A(x) B(x) = C(x) = 0 j n 1 c k x k, 0 k 2n 2 d. h. berechne die Koeffizienten c k = i,j : i+j=k a ib j. Die Folge (c 0,..., c 2n 2 ) heißt auch Konvolution (a 0,..., a n 1 ) (b 0,..., b n 1 ). Naive Benutzung der Formel liefert Θ(n 2 )-Algorithmus. Ziel: O(n log n). Methode: Divide-and-Conquer. FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

99 FFT Zentraler Trick: Benutze eine weitere Darstellung von Polynomen, die Stützstellen-Darstellung. Betrachte eine Folge (x 0,..., x n 1 ) C n von verschiedenen Stützstellen. Fakt ( Interpolation von Polynomen über Körpern) Zu jedem beliebigen Wertevektor (r 0,..., r n 1 ) C n gibt es genau ein Polynom A(x) = 0 i n 1 a ix i, also genau einen Koeffizientenvektor (a 0,..., a n 1 ), mit A(x k ) = r k für 0 k n 1. Es ist also egal, ob man für die Darstellung eines Polynoms seine Koeffizienten oder einen Wertevektor benutzt. FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

100 FFT Beweis von Fakt 1.7.1: Betrachte die Vandermonde-Matrix 1 x 0 x0 2 x n x 1 x1 2 x n 1 1 V (x 0,..., x n 1 ) = x n 1 xn 1 2 xn 1 n 1 Offensichtlich ist A(x 0 ) A(x 1 ). A(x n 1 ) = V (x 0,..., x n 1 ) a 0 a 1. a n 1. FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

101 FFT Die Matrix V (x 0,..., x n 1 ) hat Determinante 0 k<l n 1 (x l x k ) 0, ist also regulär. Daher hat das Gleichungssystem V (x 0,..., x n 1 ) a 0 a 1. a n 1 = r 0 r 1. r n 1 genau eine Lösung a 0 a 1. = V (x 0,..., x n 1 ) 1 r 0 r 1.. a n 1 r n 1 FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

102 FFT Aus der Darstellung der n-fachen Polynomauswertung als Matrix-Vektor-Produkt folgt auch: Bemerkung: Die Umrechnung von (a 0,..., a n 1 ) in (r 0,..., r n 1 ) ist eine (bijektive) lineare Abbildung von C n nach C n. Um durch Interpolation die 2n 1 Koeffizienten des Produktpolynoms C(x) zu erhalten, müssen wir mit mindestens 2n 1 Stützstellen-Werte-Paaren arbeiten. Aus technischen Gründen verwenden wir 2n viele. FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

103 FFT Algorithmenplan für die Polynommultiplikation: Eingabe: Zwei Polynome A(x) und B(x) als Koeffizientenvektoren (a 0,..., a n 1 ) und (b 0,..., b n 1 ). x 0, x 1,..., x 2n 1 seien verschiedene Stützstellen. (1) Polynomauswertung: Berechne A(x k ) und B(x k ), für k = 0,..., 2n 1. (2) Berechne durch punktweise Multiplikation Werte des Produktpolynoms C(x): C(x k ) := A(x k ) B(x k ), für k = 0,..., 2n 1. (3) Interpolation: Berechne aus (C(x 0 ), C(x 1 ),..., C(x 2n 1 )) die Koeffizienten (c 0,..., c 2n 1 ) von C(x). FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

104 FFT Kosten: (a 0,..., a n 1, b 0,..., b n 1 ) (1) Auswertung (3) Interpolation (c 0,..., c 2n 1 ) A(x k ), B(x k ), 0 k 2n 1 C(x k ), 0 k 2n 1 (2) A(x k ) B(x k ) (1)?? Naiv: Jeden Wert A(x k ) separat berechnen, z. B. mit dem Horner-Schema: A(x k ) = ((... (a n 1 x k + a n 2 ) x k...) x k + a 1 ) x k + a 0 Kosten: O(n 2 ). (2) O(n). (3)?? (Auch hier: O(n 2 ) recht leicht zu erreichen.) FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

105 FFT Kosten: (a 0,..., a n 1, b 0,..., b n 1 ) (1) O(n 2 ) (c 0,..., c 2n 1 ) (3) O(n 2 ) A(x k ), B(x k ), 0 k 2n 1 C(x k ), 0 k 2n 1 (2) O(n) Unser Ziel: O(n log n) für (1) und (3). Zunächst: Auswertung, für n = 2 L Stützstellen. FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

106 FFT Wollen dafür nutzen: Divide-and-Conquer! Idee: Nutze geschickt gewählte Stützstellen x 0,..., x n 1. Dafür: Wähle x 0,..., x n/2 1 verschieden und betrachte als Stützstellen ±x 0, ±x 1,..., ±x n/2 1. Bei der Auswertung von A(x i ) und A( x i ) wird viel Arbeit doppelt verrichtet, nämlich die Auswertung bei den geraden Potenzen von x in A(x). FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

107 FFT Ansatz: Divide-and-Conquer. Wenn n = 1, ist das Ergebnis (r 0 ) = (a 0 ). Wenn n > 1, teilen wir A(x) in zwei Teilpolynome auf: A(x) = (a 0 + a 2 x 2 + a 4 x a n 2 x n 2 ) + x(a 1 + a 3 x 2 + a 5 x a n 1 x n 2 ), mit den Abkürzungen ( gerade, ungerade ) A g (x) := a 0 + a 2 x + + a n 2 x n/2 1 und A u (x) := a 1 + a 3 x + + a n 1 x n/2 1 also A(x) = A g (x 2 ) + xa u (x 2 ). (2) FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

108 FFT A(x) = A g (x 2 ) + xa u (x 2 ). Dann gilt für Plus-Minus -Paare von Stützstellen: A(x i ) = A g (xi 2 ) + x i A u (xi 2 ) A( x i ) = A g (xi 2 ) x i A u (xi 2 ) Also: 2 Teilprobleme der Größe n/2, O(1) Aufwand zum Kombinieren. FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

109 FFT Problem: Auf oberster Rekursionsstufe: ±x 0,..., ±x n/2 1 als Plus-Minus -Paare gewählt. Im rekursiven Aufruf: x0 2,..., x n/2 1 2 müssen wieder die Eigenschaft besitzen, dass wir Plus-Minus -Paare dort finden! Wie soll das gehen? FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

110 FFT ω sei primitive n-te Einheitswurzel, d. h. (i) ω n = 1, (ii) für 1 k n 1 gilt 0 j n 1 (iii) ω k 1, für 1 k n 1. (ω k ) j = 0. Unter einfachen weiteren Voraussetzungen sind (ii) und (iii) äquivalent: Wenn ω k = 1 ist, dann folgt 0 j n 1 (ωk ) j = n. Daher folgt (iii), wenn (ii) und n 0 gelten. Wenn ω k 1 gilt, schreiben wir: (ω k 1)( 0 j n 1 (ωk ) j ) = (ω k ) n 1 = 0. Daher folgt (ii), wenn (iii) gilt und zudem die Inversen (ω k 1) 1 existieren. FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

111 FFT In C: Eine primitive n-te Einheitswurzel ist ω := e 2πi/n = cos(2π/n) + i sin(2π/n), wobei hier i die imaginäre Einheit ist. (Beweis dieser Eigenschaft: später.) In der komplexen Zahlenebene liegt der Punkt ω also auf dem Einheitskreis, von 1 aus um den Winkel 2π/n gegen den Uhrzeigersinn verdreht. Die Potenzen ω k, 0 k n 1, liegen in gleichen Abständen auf dem Einheitskreis. FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

112 FFT i 4π n ω 2 ω 2π n π n + π i FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

113 FFT Für n = 2 L gilt: ω 0 = 1, ω n/2 = 1. Also j {0,..., n/2 1} : ω j = ω n/2+j. Wir finden also ±-Paare. ω 2 ist selbst eine primitive Einheitswurzel für n/2. Im Rekursionsschritt werden wir wieder ±-Paare finden. FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

114 FFT 16 Stützstellen. Rekursion: 8 Stützstellen. i 4π n i 4π n ω 2π n ω π n + π i 4π n + π i FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

115 FFT Als (x 0, x 1,..., x n 1 ) wählen wir (ω 0, ω 1,..., ω n 1 ). (Beachte: ω 0 = 1, ω 1 = ω.) Gegeben A(x) = 0 i n 1 a ix i als Koeffizientenvektor (a 0, a 1,..., a n 1 ), wollen wir also die diskrete Fourier-Transformierte (r 0, r 1,..., r n 1 ) = (A(1), A(ω), A(ω 2 ),..., A(ω n 1 )) von (a 0,..., a n 1 ) berechnen. Die Operation (a 0,..., a n 1 ) (A(1), A(ω), A(ω 2 ),..., A(ω n 1 )) heißt die diskrete Fourier-Transformation. Es handelt sich dabei um eine lineare Bijektion von C n nach C n. (Es gibt auch eine Fourier-Transformation für Funktionen, die auf Integralen beruht.) FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

116 FFT Der Ablauf ist wie folgt: A(x) = A g (x 2 ) + xa u (x 2 ). Wir berechnen zunächst rekursiv die n Werte (s 0,..., s n/2 1 ) = (A g ((ω 2 ) 0 ), A g ((ω 2 ) 1 ),..., A g ((ω 2 ) n/2 1 )) und (t 0,..., t n/2 1 ) = (A u ((ω 2 ) 0 ), A u ((ω 2 ) 1 ),..., A u ((ω 2 ) n/2 1 )). FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

117 FFT Erinnerung: Für ±-Paare gilt: A(x i ) = A g (xi 2 ) + x i A u (xi 2 ) A( x i ) = A g (xi 2 ) x i A u (xi 2 ) Also wird (r 0, r 1,..., r n 1 ) wie folgt berechnet: Für j = 0,..., n/2 1: r j = A(ω j ) = A g ((ω j ) 2 ) + ω j A u ((ω j ) 2 ) = s j + ω j t j. r n/2+j = A( ω j ) = A g ((ω 2 ) j ) ω j A u ((ω 2 ) j ) = s j ω j t j. FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

118 FFT Algorithmus FFT (Schnelle Fourier-Transformation) Eingabe: (Koeffizienten-)Vektor (a 0,..., a n 1 ), für Zweierpotenz n; primitive n-te Einheitswurzel ω. if n = 1 then return (a 0 ); (s 0,..., s n/2 1 ) := FFT((a 0, a 2,..., a n 2 ), ω 2 ); (t 0,..., t n/2 1 ) := FFT((a 1, a 3,..., a n 1 ), ω 2 ); for j from 0 to n/2 1 do r j := s j + ω j t j ; r n/2+j := s j ω j t j ; return (r 0, r 1,..., r n 1 ). FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

119 FFT Korrektheit: Folgt aus den vorangegangenen Überlegungen. Laufzeit: Entscheidend ist die Anzahl C(n) der arithmetischen Operationen bei Eingaben der Länge n. Rekurrenz: C(n) { 1, falls n = 1 2 C(n/2) + cn, sonst, für eine Konstante c. Mit dem Master-Theorem, 2. Fall, ergibt sich C(n) = O(n log n). FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

120 FFT Satz Algorithmus FFT berechnet die diskrete Fouriertransformierte eines Koeffizientenvektors im Bezug auf die Stützstellen (1, ω, ω 2,..., ω n 1 ), wobei ω eine primitive n-te Einheitswurzel ist, in Zeit O(n log n). FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester

121 FFT Kurzer Einschub: Beweis dafür, dass ω eine n-te Einheitswurzel ist. Wissen schon, dass (i) gilt. (ii) Für jedes beliebige y gilt y j = (1 + y)(1 + y 2 )(1 + y 4 ) (1 + y 2L 1 ). (3) 0 j n 1 (Ausmultiplizieren des Produkts ergibt n = 2 L Summanden y j, bei denen jeder Exponent j {0,..., 2 L 1} genau einmal vorkommt, wegen der Eindeutigkeit der Binärdarstellung.) Wir betrachten (3) für y = ω k, für 1 k n 1. Schreibe k = u 2 l, mit u ungerade und 0 l < L. Dann ist (ω k ) 2L l 1 = ω u(2l 1) = (ω n/2 ) u = ( 1) u = 1, weil u ungerade ist. Also ist der Faktor (1 + (ω k ) 2L l 1 ) in (3) gleich 0, also ist 0 j n 1 (ωk ) j = 0. FG KTuEA, TU Ilmenau Effiziente Algorithmen Sommersemester