SS10 Effiziente Algorithmen Vorbemerkungen und 1. Kapitel

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

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

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

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

Hörer: Informatikstudierende (Bachelor) im 4. Semester, Mathematikstudierende, andere Fächer bei Bedarf Material: Eigene Mitschrift Folienkopien, Übungsblätter auf der folgenden Webseite: http://www.tu-ilmenau.de/fakia/ea_ss10.html FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel 0+1 1

Hörer: Informatikstudierende (Bachelor) im 4. Semester, Mathematikstudierende, andere Fächer bei Bedarf Material: Eigene Mitschrift Folienkopien, Übungsblätter auf der folgenden Webseite: http://www.tu-ilmenau.de/fakia/ea_ss10.html Zugang über die Institutsseite. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel 0+1 1

Hörer: Informatikstudierende (Bachelor) im 4. Semester, Mathematikstudierende, andere Fächer bei Bedarf Material: Eigene Mitschrift Folienkopien, Übungsblätter auf der folgenden Webseite: http://www.tu-ilmenau.de/fakia/ea_ss10.html Zugang über die Institutsseite. Stoff: Vorlesung + Übungsaufgaben. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel 0+1 1

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

Zeitaufwand? Leistungspunkte: 4 LP Entspricht 120 Zeitstunden. Vorlesungszeit: 15 Wochen. 6 Stunden pro Woche Davon: 2 1 2 3 in Vorlesung/Übung Zeitaufwand: 3 3 1 2 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

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

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

Ü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, 15 20 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

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

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

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

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

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

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

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 0+1 13

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

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

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

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 0+1 15

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 0+1 15

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 0+1 16

1.1 Multiplikation ganzer Zahlen FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel 0+1 17

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 0+1 17

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 0+1 17

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 0+1 17

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 0+1 17

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 0+1 18

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 0+1 18

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 0+1 18

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

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, 101010, 11110 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 0+1 18

Multiplikation zweier natürlicher Zahlen FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel 0+1 19

Multiplikation zweier natürlicher Zahlen Schulmethode FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel 0+1 19

Multiplikation zweier natürlicher Zahlen Schulmethode 1 0 0 1 1 0 1 1 0 0 1 1 : 1 0 0 1 1 0 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 1 0 1 0 0 1 1 0 Überträge: 0 0 1 10 1 0 1 1 0 0 0 Produkt: 1 1 1 1 0 0 1 0 0 1 0 FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel 0+1 19

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

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 ) 0... 0 }{{} i Nullen und addiere alle diese. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel 0+1 20

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 ) 0... 0 }{{} 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 0+1 20

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 ) 0... 0 }{{} 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 0+1 20

Multiplikation mit Divide-and-Conquer: FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel 0+1 21

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

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 0+1 21

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 0+1 21

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 0+1 21

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 0+1 21

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 0+1 21

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 0+1 22

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 0+1 22

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 0+1 23

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 0+1 23

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 0+1 23

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 0+1 23

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 0+1 23

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 0+1 23

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 0+1 23

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 0+1 24

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

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

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 0+1 25

Beispiel: Mit Dezimalzahlen, n 0 = 2. Methode funktioniert zu jeder Basis! In der Informatik interessante Basiszahlen: 2, 8, 10, 16, 256, 2 16, 2 32,... n = 8, x = 76490358, y = 35029630. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel 0+1 25

Beispiel: Mit Dezimalzahlen, n 0 = 2. Methode funktioniert zu jeder Basis! In der Informatik interessante Basiszahlen: 2, 8, 10, 16, 256, 2 16, 2 32,... n = 8, x = 76490358, y = 35029630. A = 7649, B = 0358, C = 3502, D = 9630. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel 0+1 25

Beispiel: Mit Dezimalzahlen, n 0 = 2. Methode funktioniert zu jeder Basis! In der Informatik interessante Basiszahlen: 2, 8, 10, 16, 256, 2 16, 2 32,... n = 8, x = 76490358, y = 35029630. A = 7649, B = 0358, C = 3502, D = 9630. E = A B = 7291, F = C D = 6128. Jeweils 4 Dezimalziffern. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel 0+1 25

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

Weil z.b. n 0 = 2 ist, wird direkt multipliziert: g = 76 35 = 2660, h = 98, i = 27 33 = 891. 3 Multiplikationen von 2-Bit-Zahlen. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel 0+1 26

Weil z.b. n 0 = 2 ist, wird direkt multipliziert: g = 76 35 = 2660, h = 98, i = 27 33 = 891. 3 Multiplikationen von 2-Bit-Zahlen. Ergebnis: G = AC = 2660 10 4 +(2660+98 891) 10 2 +98 = 26786798. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel 0+1 26

Weil z.b. n 0 = 2 ist, wird direkt multipliziert: g = 76 35 = 2660, h = 98, i = 27 33 = 891. 3 Multiplikationen von 2-Bit-Zahlen. Ergebnis: G = AC = 2660 10 4 +(2660+98 891) 10 2 +98 = 26786798. Analog, rekursiv: H = BD = 03447540, I = E F = 44679248. Ergebnis: x y = 26786798 10 8 + (26786798 + 03447540 ( 1) 44679248) 10 4 + 03447540 = 2679428939307540 FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel 0+1 26

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

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 0+1 27

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 0+1 27

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 0+1 27

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 0+1 27

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 0+1 27

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 0+1 27

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 0+1 28

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 0+1 28

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 0+1 28

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 0+1 28

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

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 0+1 29

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 0+1 29

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 0+1 29

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 0+1 29

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 0+1 29

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 0+1 29

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

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,58496. Deutlich kleiner als n 2! FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel 0+1 29

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 0+1 30

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 0+1 30

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 0+1 30

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 0+1 30

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 0+1 30

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 3 2 2 l 2 + c 3 2 l 1 + c 2 l FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel 0+1 30

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 3 2 2 l 2 + c 3 2 l 1 + c 2 l. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel 0+1 30

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 3 2 2 l 2 + c 3 2 l 1 + c 2 l. 3 l T Ka (2 0 ) + c 3 j 2 l j 0 j l 1 FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel 0+1 30

T (2 l ) FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel 0+1 31

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 0+1 31

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 2 3 j 2 l j ) j FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel 0+1 31

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 1 3 2 1 < 3 l + c 3l 1 2 ( 3 2 3 j 2 l j ) j FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel 0+1 31

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 1 3 2 1 < 3 l + c 3l 1 2 < (1 + 2c) 3 l. ( 3 2 3 j 2 l j ) j FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel 0+1 31

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 1 3 2 1 < 3 l + c 3l 1 2 < (1 + 2c) 3 l. Also: T (n) (1 + 2c)n log 2 3 = O(n 1,585 ). ( 3 2 3 j 2 l j ) j FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel 0+1 31

Satz 1.1.1 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 0+1 32

Satz 1.1.1 Beim Karatsuba-Multiplikationsalgorithmus beträgt die Anzahl der Bitoperationen und die Rechenzeit O(n log 2 3 ) = O(n 1,585 ). In der Praxis (Implementierung in Software): FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel 0+1 32

Satz 1.1.1 Beim Karatsuba-Multiplikationsalgorithmus beträgt die Anzahl der Bitoperationen und die Rechenzeit O(n log 2 3 ) = O(n 1,585 ). In der Praxis (Implementierung in Software): Nicht n 0 = 1 wählen, sondern für Zahlen einer Länge bis zur Wortgröße des Rechners (z. B. n 0 = 32) die eingebaute Multiplikations- Hardware benutzen. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel 0+1 32

Satz 1.1.1 Beim Karatsuba-Multiplikationsalgorithmus beträgt die Anzahl der Bitoperationen und die Rechenzeit O(n log 2 3 ) = O(n 1,585 ). In der Praxis (Implementierung in Software): Nicht n 0 = 1 wählen, sondern für Zahlen einer Länge bis zur Wortgröße des Rechners (z. B. 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 0+1 32

Satz 1.1.1 Beim Karatsuba-Multiplikationsalgorithmus beträgt die Anzahl der Bitoperationen und die Rechenzeit O(n log 2 3 ) = O(n 1,585 ). In der Praxis (Implementierung in Software): Nicht n 0 = 1 wählen, sondern für Zahlen einer Länge bis zur Wortgröße des Rechners (z. B. 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 0+1 32

Beispiele: FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel 0+1 33

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

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 0+1 33

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 0+1 33

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 0+1 33

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 0+1 33

Zahlen mit 32768 Binärziffern haben etwa 9900 Dezimalziffern. M Ka (215 ) = 3 15 5 M Ka (25 ) = 3 10 = 59049. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel 0+1 34

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

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

Geht es noch besser? FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel 0+1 35

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

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

Geht es noch besser? Theoretisch ja, praktisch eigentlich kaum. Mitteilung: Schönhage-Strassen (1971): Multiplikation zweier n-bit- Zahlen mit O(n log n log log n) Gattern. Arnold Schönhage und Volker Strassen: Schnelle Multiplikation großer Zahlen, Computing 7, 1971, Springer Verlag, S. 281 292 FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel 0+1 35

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

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 0+1 36

Dabei ist log n definiert als die kleinste Zahl i mit log log... log n 1. }{{} i mal Also: log 2 = 1, log 4 = 2, log 16 = 3, log 65536 = 4, log (2 65536 ) = 5, log (2 265536 ) = 6, und 2 265536 ist schon eine sehr große Zahl. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel 0+1 36

Dabei ist log n definiert als die kleinste Zahl i mit log log... log n 1. }{{} i mal Also: log 2 = 1, log 4 = 2, log 16 = 3, log 65536 = 4, log (2 65536 ) = 5, log (2 265536 ) = 6, und 2 265536 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 0+1 36

1.2 Matrixmultiplikation FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel 0+1 37

Es sei R irgendein Ring. 1.2 Matrixmultiplikation FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel 0+1 37

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 0+1 37

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 0+1 37

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 0+1 37

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 0+1 37

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 0+1 37

Wir nehmen an: n = 2 l, Zweierpotenz. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel 0+1 38

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

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 0+1 38

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 0+1 38

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 0+1 38

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 0+1 38

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

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 0+1 39

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 0+1 39

Strassen-Trick: 7 Multiplikationen genügen. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel 0+1 40

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 0+1 40

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 0+1 40

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 0+1 40

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 0+1 40

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 0+1 40

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 0+1 41

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 0+1 41

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 0+1 41

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 0+1 41

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 0+1 41

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 0+1 41

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 0+1 41

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 0+1 41

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 0+1 41

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

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 0+1 42

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 0+1 42

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 0+1 42

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 0+1 42

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 3 4 0 j l 1 (7/4) j 7 j (2 2 ) l j FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel 0+1 42

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 0+1 42

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 0+1 42

1.3 Erinnerung: Mergesort FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel 0+1 43

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 0+1 43

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 0+1 43

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 0+1 43

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 0+1 43

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 0+1 43

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

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 0+1 44

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 0+1 44

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 0+1 44

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 1 2 3 4 5 6 7 8 9 10 11 12 13 14... C(n) 0 1 3 5 8 11 14 17 21 25 29 33 37 41... FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel 0+1 44

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+1 + 1.) Satz 1.3.1 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 0+1 45

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

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 0+1 47

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 0+1 48

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 0+1 49

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 0+1 50

Lemma 1.4.1 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 0+1 51

Lemma 1.4.1 Wenn v ein Knoten auf Level i ist, dann gilt: B(n/b i ) Summe der Einträge im Unterbaum unter v. (Beweis durch Induktion über l i.) FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel 0+1 51

Lemma 1.4.1 Wenn v ein Knoten auf Level i ist, dann gilt: B(n/b i ) Summe der Einträge im Unterbaum unter v. (Beweis durch Induktion über l i.) Also: B(n) Summe aller Einträge im Baum. FG KTuEA, TU Ilmenau Effiziente Algorithmen SS10 Kapitel 0+1 51

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 0+1 52

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 0+1 53

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 0+1 54