SS10 Effiziente Algorithmen Vorbemerkungen und 1. Kapitel

Transkript

1 SS10 Effiziente Algorithmen Vorbemerkungen und 1. Kapitel Martin Dietzfelbinger April 2010 FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel 0+1

2 Hörer: Informatikstudierende (Bachelor) im 4. Semester, Mathematikstudierende, andere Fächer bei Bedarf FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel 0+1 1

3 Hörer: Informatikstudierende (Bachelor) im 4. Semester, Mathematikstudierende, andere Fächer bei Bedarf Material: Eigene Mitschrift FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel 0+1 1

4 Hörer: Informatikstudierende (Bachelor) im 4. Semester, Mathematikstudierende, andere Fächer bei Bedarf Material: Eigene Mitschrift Folienkopien, Übungsblätter FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel 0+1 1

5 Hörer: Informatikstudierende (Bachelor) im 4. Semester, Mathematikstudierende, andere Fächer bei Bedarf Material: Eigene Mitschrift Folienkopien, Übungsblätter auf der folgenden Webseite: FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel 0+1 1

6 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. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel 0+1 1

7 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 SS10 Kapitel 0+1 1

8 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 SS10 Kapitel 0+1 2

9 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 SS10 Kapitel 0+1 3

10 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 SS10 Kapitel 0+1 4

11 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 SS10 Kapitel 0+1 5

12 Übungsleiter: Herr Dipl.-Inf. Martin Aumüller Dienstag (U), 15:00-16:30, HU201 Mittwoch (G), 11:00-12:30, HU011 Mittwoch (G), 13:00-14:30, HU129 Prüfung: (Bachelor Informatik) September 2009, Min. mündlich (andere) nach Vereinbarung, mündlich. Bonuspunkte: Korrektes Vorrechnen einer (markierten) Übungsaufgabe mit vorheriger schriftlicher Abgabe ˆ= Notenverbesserung um 0,3 (maximal 2mal pro Person, nicht automatisch von 5,0 auf 4,0). FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel 0+1 6

13 Themen: 1. Divide-and-Conquer Multiplikation ganzer Zahlen: Algorithmus von Karatsuba Matrixmultiplikation: Algorithmus von Strassen Erinnerung: Mergesort 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 FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel 0+1 7

14 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 SS10 Kapitel 0+1 8

15 3. Greedy-Strategie allgemein Teilbares Rucksackproblem Schedulingprobleme Kürzeste Wege 1: Algorithmus von Dijkstra Priority-Queues mittels binärer Heaps Huffman-Kodierung FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel 0+1 9

16 4. Minimale Spannbäume: Greedy-Strategien, Hilfsstrukturen Union-Find-Datenstruktur MST: Schnitteigenschaft MST: Algorithmus von Kruskal MST: Algorithmus von Prim FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

17 5. Dynamische Programmierung Editierdistanz Matrix-Ketten-Multiplikation Kürzeste Wege 2: Algorithmus von Floyd-Warshall, Transitive Hülle Kürzeste Wege 3: Algorithmus von Bellman-Ford Optimale binäre Suchbäume FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

18 6. Textsuche Textsuche mit Automaten Knuth-Morris-Pratt-Algorithmus Karp-Rabin-Algorithmus, randomisiert FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

19 7. Flüsse in Netzwerken Das Problem Maximaler Fluss in Netzwerk Algorithmus von Ford-Fulkerson Max-Flow-Min-Cut-Theorem Algorithmus von Edmonds-Karp: Voll polynomiell Maximales Matching in bipartiten Graphen FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

20 Kapitel 1 Divide-and-Conquer (D-a-C) Ein Algorithmenparadigma. Divide-and-Conquer divide et impera teile und herrsche FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

21 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. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

22 Falls n = x n 0 (Größenschranke): löse P auf x direkt. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

23 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, was Lösungen r 1,..., r a liefert. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

24 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, was Lösungen r 1,..., r a liefert. 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 SS10 Kapitel

25 Standardbeispiele aus AuD für D-a-C-Algorithmen: Mergesort Quicksort Binäre Suche Fortgeschrittenes Beispiel (nicht in dieser Vorlesung): Schnelle Fouriertransformation FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

26 1.1 Multiplikation ganzer Zahlen FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

27 1.1 Multiplikation ganzer Zahlen Zahlen in Binärdarstellung! (Methoden funktionieren im Prinzip für jede beliebige Basis.) FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

28 1.1 Multiplikation ganzer Zahlen Zahlen in Binärdarstellung! (Methoden funktionieren im Prinzip für jede beliebige Basis.) Grundlage: Serielle Binäraddition FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

29 1.1 Multiplikation ganzer Zahlen Zahlen in Binärdarstellung! (Methoden funktionieren im Prinzip für jede beliebige Basis.) Grundlage: Serielle Binäraddition Input: Binärzahlen/-strings a n 1... a 0 und b n 1... b 0 FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

30 1.1 Multiplikation ganzer Zahlen Zahlen in Binärdarstellung! (Methoden funktionieren im Prinzip für jede beliebige Basis.) Grundlage: Serielle Binäraddition Input: Binärzahlen/-strings a n 1... a 0 und b n 1... b 0 Volladierer (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 SS10 Kapitel

31 c 0 0; 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. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

32 c 0 0; 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. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

33 c 0 0; 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. Negative Zahlen, Subtraktion FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

34 c 0 0; 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. Negative Zahlen, Subtraktion Im Folgenden: Ganze Zahlen werden als Paar (Vorzeichen, Absolutbetrag) dargestellt, z, B.: 10, 1001, , FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

35 c 0 0; 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. Negative Zahlen, Subtraktion Im Folgenden: Ganze Zahlen werden als Paar (Vorzeichen, Absolutbetrag) dargestellt, z, B.: 10, 1001, , Additionen und Subtraktionen solcher Zahlen sind mit der Zweierkomplementdarstellung auf die Addition zurückführbar, kosten nicht mehr als 10n Bitoperationen. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

36 Multiplikation zweier natürlicher Zahlen FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

37 Multiplikation zweier natürlicher Zahlen Schulmethode FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

38 Multiplikation zweier natürlicher Zahlen Schulmethode : Überträge: Produkt: FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

39 Allgemein: Input: Binärzahlen/-strings a n 1... a 0 und b n 1... b 0 FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

40 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. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

41 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 FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

42 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 SS10 Kapitel

43 Multiplikation mit Divide-and-Conquer: FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

44 Multiplikation mit Divide-and-Conquer: Eingabe: n-bit-binärzahlen x und y, eventuell mit Vorzeichen. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

45 Multiplikation mit Divide-and-Conquer: Eingabe: n-bit-binärzahlen x und y, eventuell mit Vorzeichen. Falls n n 0 : Benutze Schulmethode. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

46 Multiplikation mit Divide-and-Conquer: Eingabe: n-bit-binärzahlen x und y, eventuell mit Vorzeichen. Falls n n 0 : Benutze Schulmethode. Falls n > n 0 : Setze k = n/2. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

47 Multiplikation mit Divide-and-Conquer: Eingabe: n-bit-binärzahlen x und y, eventuell mit 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 FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

48 Multiplikation mit Divide-and-Conquer: Eingabe: n-bit-binärzahlen x und y, eventuell mit 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. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

49 Multiplikation mit Divide-and-Conquer: Eingabe: n-bit-binärzahlen x und y, eventuell mit 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. Also x y = (A 2 k +B)(C 2 k +D) = AC 2 2k +(AD+BC) 2 k +BD. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

50 Erste Idee: Berechne rekursiv AC, AD, BC, CD, und füge die Produkte durch einige Additionen zum Resultat x y zusammen. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

51 Erste Idee: Berechne rekursiv AC, AD, BC, CD, 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 ): (1) Die Anzahl der Bitoperationen ist wieder Θ(n 2 ), nicht besser als Schulmethode. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

52 x y = (A 2 k + B)(C 2 k + D) = AC 2 2k + (AD + BC) 2 k + BD. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

53 x y = (A 2 k + B)(C 2 k + D) = AC 2 2k + (AD + BC) 2 k + BD. Trick: FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

54 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... ) FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

55 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 Differenz zweier nichtnegativer k-bit-zahlen höchstens k Bits. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

56 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 Differenz zweier nichtnegativer k-bit-zahlen höchstens k Bits. Nun: E F = (A B)(C D) = AC + BD (AD + BC). FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

57 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 Differenz zweier nichtnegativer k-bit-zahlen höchstens k Bits. Nun: E F = (A B)(C D) = AC + BD (AD + BC). Also: AD + BC = AC + BD EF. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

58 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 Differenz zweier nichtnegativer k-bit-zahlen höchstens k Bits. Nun: E F = (A B)(C D) = AC + BD (AD + BC). Also: AD + BC = AC + BD EF. Eingesetzt: x y = AC 2 2k + (AC + BD EF ) 2 k + BD. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

59 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 SS10 Kapitel

60 Beispiel: Mit Dezimalzahlen, n 0 = 2. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

61 Beispiel: Mit Dezimalzahlen, n 0 = 2. Methode funktioniert zu jeder Basis! FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

62 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,... FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

63 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 = FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

64 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 = FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

65 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. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

66 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 SS10 Kapitel

67 Weil z.b. n 0 = 2 ist, wird direkt multipliziert: g = = 2660, h = 98, i = = Multiplikationen von 2-Bit-Zahlen. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

68 Weil z.b. n 0 = 2 ist, wird direkt multipliziert: g = = 2660, h = 98, i = = Multiplikationen von 2-Bit-Zahlen. Ergebnis: G = AC = ( ) = FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

69 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) ) = FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

70 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 SS10 Kapitel

71 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: AC, BD, EF berechnen FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

72 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: AC, BD, EF berechnen und müssen einige Additionen und Subtraktionen von Zahlen mit maximal 2n Bits durchführen: O(n) Bitoperationen. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

73 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: AC, BD, EF berechnen und müssen einige Additionen und Subtraktionen von Zahlen mit maximal 2n Bits durchführen: O(n) Bitoperationen. Einfachst-Analyse: FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

74 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: AC, BD, EF berechnen und müssen einige Additionen und Subtraktionen von Zahlen mit maximal 2n Bits durchführen: O(n) Bitoperationen. Einfachst-Analyse: Es sei n 0 = 1 und n sei eine Zweiterpotenz: n = 2 l. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

75 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: AC, BD, EF berechnen und müssen einige Additionen und Subtraktionen von Zahlen mit maximal 2n Bits durchführen: O(n) Bitoperationen. Einfachst-Analyse: Es sei n 0 = 1 und n sei eine Zweiterpotenz: n = 2 l. M Ka (n) = Anzahl der Bit-Multiplikationen ( -Operationen). FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

76 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: AC, BD, EF berechnen und müssen einige Additionen und Subtraktionen von Zahlen mit maximal 2n Bits durchführen: O(n) Bitoperationen. Einfachst-Analyse: Es sei n 0 = 1 und n sei eine Zweiterpotenz: n = 2 l. M Ka (n) = Anzahl der Bit-Multiplikationen ( -Operationen). T Ka (n) = Anzahl der Bit-Operationen. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

77 T Ka (n 0 ) = 1 und T Ka (n) 3T Ka (n/2)+cn, wobei c konstant ist. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

78 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). FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

79 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. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

80 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 nur auf dem untersten Rekursionslevel. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

81 M Ka (n 0 ) = 1 und M Ka (n) = 3M Ka (n/2). FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

82 M Ka (n 0 ) = 1 und M Ka (n) = 3M Ka (n/2). M Ka (2 l ) = 3 M Ka (2 l 1 ) FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

83 M Ka (n 0 ) = 1 und M Ka (n) = 3M Ka (n/2). M Ka (2 l ) = 3 M Ka (2 l 1 ) = 3 2 M Ka (2 l 2 ) FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

84 M Ka (n 0 ) = 1 und M Ka (n) = 3M 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 ) FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

85 M Ka (n 0 ) = 1 und M Ka (n) = 3M 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 ) FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

86 M Ka (n 0 ) = 1 und M Ka (n) = 3M 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. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

87 M Ka (n 0 ) = 1 und M Ka (n) = 3M 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. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

88 M Ka (n 0 ) = 1 und M Ka (n) = 3M 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, FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

89 M Ka (n 0 ) = 1 und M Ka (n) = 3M 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 SS10 Kapitel

90 T Ka (n 0 ) = 1 und T Ka (n) 3T Ka (n/2) + cn, wobei c konstant. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

91 T Ka (n 0 ) = 1 und T Ka (n) 3T Ka (n/2) + cn, wobei c konstant. T (2 l ) FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

92 T Ka (n 0 ) = 1 und T Ka (n) 3T Ka (n/2) + cn, wobei c konstant. T (2 l ) 3 T Ka (2 l 1 ) + c 2 l FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

93 T Ka (n 0 ) = 1 und T Ka (n) 3T Ka (n/2) + cn, wobei c konstant. T (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 FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

94 T Ka (n 0 ) = 1 und T Ka (n) 3T Ka (n/2) + cn, wobei c konstant. T (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 FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

95 T Ka (n 0 ) = 1 und T Ka (n) 3T Ka (n/2) + cn, wobei c konstant. T (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 FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

96 T Ka (n 0 ) = 1 und T Ka (n) 3T Ka (n/2) + cn, wobei c konstant. T (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. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

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

98 T (2 l ) FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

99 T (2 l ) 3 l T Ka (2 0 ) + c 0 j l 1 3 j 2 l j FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

100 T (2 l ) 3 l T Ka (2 0 ) + c 3 l 1 + c 2 l 0 j l 1 0 j l 1 ( j 2 l j ) j FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

101 T (2 l ) 3 l T Ka (2 0 ) + c 3 l 1 + c 2 l 0 j l 1 0 j l 1 = 3 l + c 2 l (3 2 )l < 3 l + c 3l 1 2 ( j 2 l j ) j FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

102 T (2 l ) 3 l T Ka (2 0 ) + c 3 l 1 + c 2 l 0 j l 1 0 j l 1 = 3 l + c 2 l (3 2 )l < 3 l + c 3l 1 2 < (1 + 2c) 3 l. ( j 2 l j ) j FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

103 T (2 l ) 3 l T Ka (2 0 ) + c 3 l 1 + c 2 l 0 j l 1 0 j l 1 = 3 l + c 2 l (3 2 )l < 3 l + c 3l 1 2 < (1 + 2c) 3 l. Also: T (n) (1 + 2c)n log 2 3 = O(n 1,585 ). ( j 2 l j ) j FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

104 Satz Beim Karatsuba-Multiplikationsalgorithmus beträgt die Anzahl der Bitoperationen und die Rechenzeit O(n log 2 3 ) = O(n 1,585 ). FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

105 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): FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

106 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. n 0 = 32) die eingebaute Multiplikations- Hardware benutzen. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

107 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. n 0 = 32) die eingebaute Multiplikations- Hardware benutzen. Nur für längere Zahlen den Karatsuba-Trick benutzen. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

108 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. n 0 = 32) die eingebaute Multiplikations- Hardware benutzen. Nur für längere Zahlen den Karatsuba-Trick benutzen. Welches n 0 das optimale ist, hängt von der Hardware und eventuell von Programmierdetails ab. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

109 Beispiele: FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

110 Beispiele: Zahlen mit 1024 Binärziffern haben gut 300 Dezimalziffern. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

111 Beispiele: Zahlen mit 1024 Binärziffern haben gut 300 Dezimalziffern. (Will man mit so riesigen Zahlen rechnen?) FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

112 Beispiele: Zahlen mit 1024 Binärziffern haben gut 300 Dezimalziffern. (Will man mit so riesigen Zahlen rechnen?) Ja! Kryptographie! FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

113 Beispiele: Zahlen mit 1024 Binärziffern haben gut 300 Dezimalziffern. (Will man mit so riesigen Zahlen rechnen?) Ja! Kryptographie! Wir betrachten nur die Anzahl der Multiplikationen von 32- Bit-Zahlen: M Ka (210 ) = 3 l 5 M Ka (25 ) = 3 5 = 243. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

114 Beispiele: Zahlen mit 1024 Binärziffern haben gut 300 Dezimalziffern. (Will man mit so riesigen Zahlen rechnen?) Ja! Kryptographie! Wir betrachten nur die Anzahl der Multiplikationen von 32- Bit-Zahlen: M Ka (210 ) = 3 l 5 M Ka (25 ) = 3 5 = 243. Bei Verwendung der Schulmethode (und der Hardware für die kurzen Zahlen) ergeben sich (2 l 5 ) 2 = 1024 Multiplikationen. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

115 Zahlen mit Binärziffern haben etwa 9900 Dezimalziffern. M Ka (215 ) = M Ka (25 ) = 3 10 = FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

116 Zahlen mit Binärziffern haben etwa 9900 Dezimalziffern. M Ka (215 ) = M Ka (25 ) = 3 10 = Bei Verwendung der Schulmethode: ( ) 2 = 2 20 Multiplikationen, mehr als 1 Million! FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

117 Zahlen mit Binärziffern haben etwa 9900 Dezimalziffern. M Ka (215 ) = M Ka (25 ) = 3 10 = Bei Verwendung der Schulmethode: ( ) 2 = 2 20 Multiplikationen, mehr als 1 Million! Ersparnis: Faktor 18. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

118 Geht es noch besser? FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

119 Geht es noch besser? Theoretisch ja, praktisch eigentlich kaum. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

120 Geht es noch besser? Theoretisch ja, praktisch eigentlich kaum. Mitteilung: FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

121 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 FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

122 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 SS10 Kapitel

123 Dabei ist log n definiert als die kleinste Zahl i mit log log... log n 1. }{{} i mal FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

124 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. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

125 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 SS10 Kapitel

126 1.2 Matrixmultiplikation FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

127 Es sei R irgendein Ring. 1.2 Matrixmultiplikation FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

128 Es sei R irgendein Ring. 1.2 Matrixmultiplikation A = (a ij ) 1 i,j n, B = (b ij ) 1 i,j n seien n n-matrizen über R. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

129 1.2 Matrixmultiplikation Es sei R irgendein Ring. 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 = a ik b kj. 1 k n FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

130 Es sei R irgendein Ring. 1.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. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

131 Es sei R irgendein Ring. 1.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! FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

132 Es sei R irgendein Ring. 1.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 Effiziente Algorithmen SS10 Kapitel

133 Wir nehmen an: n = 2 l, Zweierpotenz. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

134 Wir nehmen an: n = 2 l, Zweierpotenz. Eingabe: n n-matrizen A, B. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

135 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. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

136 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: FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

137 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 = ( C D E F ), B = ( G H K L ) FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

138 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): ( ) CG + DK CH + DL A B = EG + F K EH + F L FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

139 Suggeriert rekursiven Ansatz, in dem 8 Multiplikationen von ( n 2 n 2 )-Teilmatrizen durchgeführt werden. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

140 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. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

141 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 SS10 Kapitel

142 Strassen-Trick: 7 Multiplikationen genügen. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

143 Strassen-Trick: 7 Multiplikationen genügen. 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) FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

144 Strassen-Trick: 7 Multiplikationen genügen. Dann: 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) AB = ( P5 + P 4 P 2 + P 6 P 1 + P 2 P 3 + P 4 P 1 + P 5 P 3 P 7 FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

145 Strassen-Trick: 7 Multiplikationen genügen. Dann: AB = 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! FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

146 Strassen-Trick: 7 Multiplikationen genügen. Dann: AB = 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. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

147 Strassen-Trick: 7 Multiplikationen genügen. Dann: AB = 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. (Alternative Methode, etwas komplizierter: 15 Additionen.) FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

148 Aufwandsanalyse (einfachst): Für n 0 = 1, M(n) = Anzahl der Ringmultiplikationen. (Nur im Basisfall der Rekursion!) FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

149 Aufwandsanalyse (einfachst): Für n 0 = 1, M(n) = Anzahl der Ringmultiplikationen. (Nur im Basisfall der Rekursion!) M(1) = 1; FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

150 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. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

151 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 : FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

152 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. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

153 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. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

154 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. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

155 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). FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

156 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 SS10 Kapitel

157 A(2 l ) 7 A(2 l 1 ) + c (2 2 ) l FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

158 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 FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

159 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 A(2 }{{ 0 } ) +c = 0 0 j l 1 7 j (2 2 ) l j FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

160 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 A(2 0 ) }{{} = c 4 l = 0 +c 0 j l 1 0 j l 1 (7/4) j 7 j (2 2 ) l j FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

161 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 A(2 0 ) }{{} = c 4 l = 0 +c 0 j l 1 = c 4 l (7/4)l 1 (7/4) 1 0 j l 1 (7/4) j 7 j (2 2 ) l j FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

162 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 A(2 0 ) }{{} = c 4 l = 0 +c 0 j l 1 = c 4 l (7/4)l 1 (7/4) 1 < c 7l j l 1 (7/4) j 7 j (2 2 ) l j FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

163 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 A(2 0 ) }{{} = c 4 l = 0 +c 0 j l 1 = c 4 l (7/4)l 1 (7/4) 1 0 j l 1 (7/4) j 7 j (2 2 ) l j < c 7l 3 4 < (4c/3) 7 l. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

164 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 A(2 0 ) }{{} = c 4 l = 0 +c 0 j l 1 = c 4 l (7/4)l 1 (7/4) 1 0 j l 1 (7/4) j 7 j (2 2 ) l j < c 7l 3 4 < (4c/3) 7 l. Wieder O(n log 2 7 )! Alternative: Master-Theorem. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

165 1.3 Erinnerung: Mergesort FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

166 1.3 Erinnerung: Mergesort Um n Zahlen a 1,..., a n zu sortieren, geht der Mergesort- Algorithmus so vor: FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

167 1.3 Erinnerung: Mergesort Um n Zahlen 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). FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

168 1.3 Erinnerung: Mergesort Um n Zahlen 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. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

169 1.3 Erinnerung: Mergesort Um n Zahlen 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. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

170 1.3 Erinnerung: Mergesort Um n Zahlen 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 SS10 Kapitel

171 Analyse über Rekurrenzungleichungen : Wir zählen nur Vergleiche. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

172 Analyse über Rekurrenzungleichungen : Wir zählen nur Vergleiche. C(n) = Anzahl der Vergleiche beim Sortieren von n Eingaben, schlechtester Fall. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

173 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. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

174 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. Lösung: C(n) = n log n (2 log n 1). FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

175 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. Lösung: C(n) = n log n (2 log n 1). n C(n) FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

176 Beweisansatz: Man beweist mit Induktion über l = 1, 2, 3,..., dass folgendes gilt: Für n {2 l 1,..., 2 l } gilt C(n) = nl 2 l + 1. (Dabei benutzt man, dass für n = 2 l gilt: nl 2 l + 1 = n(l + 1) 2 l ) Satz Für die Vergleichsanzahl im schlechtesten Fall bei Mergesort gilt: C(n) n log n. Beweis: Wir haben C(n) = n log n (2 log n 1). Wenn n = 2 log n, ist die Behauptung klar. Wenn n < 2 log n, ist FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

177 C(n) n(1 + log n) n = n log n. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

178 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 SS10 Kapitel

179 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 SS10 Kapitel

180 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 SS10 Kapitel

181 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 SS10 Kapitel

182 Lemma Wenn v ein Knoten auf Level i ist, dann gilt: B(n/b i ) Summe der Einträge im Unterbaum unter v. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

183 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.) FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel

184 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 SS10 Kapitel

185 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: Beitrag zu Gesamtkosten aus dem Inneren des Baums. Zweiter Term: 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 SS10 Kapitel

186 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 SS10 Kapitel

187 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 SS10 Kapitel