Vorüberlegungen, Karatsuba, Strassen
Werbung
Effiziente Algorithmen Vorüberlegungen und Divide-and-Conquer-Algorithmen Vorlesender: Martin Aumüller (nach Folien von Prof. Martin Dietzfelbinger) April 2012 FG KTuEA, TU Ilmenau Effiziente Algorithmen – Sommersemester 2012 1 Organistorisches 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/iti/lehre/lehre-ss-2012/ea/ Zugang über die Institutsseite. Stoff: Vorlesung + Übungsaufgaben. FG KTuEA, TU Ilmenau Effiziente Algorithmen – Sommersemester 2012 2 Organistorisches Zur Arbeitsweise: Der Stoff ist zu kompliziert und zu umfangreich, um durch reines Zuhören verstanden zu werden. Regelmäßig Vorlesung nacharbeiten. Semesterbegleitend! Begleitend Bücher ansehen. Übungsblätter drucken, lesen, zur Übung mitbringen, vorher Lösung ausdenken, Lösungsweg aufschreiben, an Lösungen mitarbeiten, Lösungen vortragen. Regelmäßig Übungen nacharbeiten. Semesterbegleitend! Bei Verständnisproblemen frühzeitig fragen! FG KTuEA, TU Ilmenau Effiziente Algorithmen – Sommersemester 2012 3 Organistorisches Zeitaufwand? Leistungspunkte: 4 LP – Entspricht 120 Zeitstunden. Vorlesungszeit: 15 Wochen. 6 Stunden pro Woche Davon: 2 12 – 3 in Vorlesung/Übung Zeitaufwand: 3 – 3 12 Zeitstunden pro Woche neben Vorlesung + Übung! ergibt: 90 Stunden plus 30 Stunden Prüfungsvorbereitung! FG KTuEA, TU Ilmenau Effiziente Algorithmen – Sommersemester 2012 4 Organistorisches Literaturvorschläge: T. H. Cormen, C. E. Leiserson, R. L. Rivest, C. Stein, Introduction to Algorithms, 2nd ed., MIT Press, 2001 (auch auf deutsch bei Oldenbourg) S. Dasgupta, C. Papadimitriou, U. Vazirani, Algorithms, McGraw-Hill, 2007 V. Heun, Grundlegende Algorithmen, 2. Auflage, Vieweg, 2003 J. Kleinberg, E. Tardos, Algorithm Design, Pearson Education, 2005 K. Mehlhorn, P. Sanders, Algorithms and Data Structures: The Basic Toolbox, Springer-Verlag, 2008 FG KTuEA, TU Ilmenau Effiziente Algorithmen – Sommersemester 2012 5 Organistorisches Literaturvorschläge: T. Ottmann, P. Widmayer, Algorithmen und Datenstrukturen, Spektrum Akademischer Verlag, 2002 U. Schöning, Algorithmik, Spektrum Akademischer Verlag, 2001 R. Sedgewick, Algorithms, Addison-Wesley, 2002 (auch C-, C++, Java-Versionen, auch auf deutsch bei Pearson) R. Sedgewick, Algorithms, Part 5: Graph Algorithms, Addison-Wesley, 2003 Vorlesung folgt eigenem Plan, nicht direkt einem Buch. FG KTuEA, TU Ilmenau Effiziente Algorithmen – Sommersemester 2012 6 Organistorisches Übungen: • Dienstag (U), 15:00-16:30, HU 011 • Mittwoch (U), 11:00-12:30, HU 011 • Mittwoch (U), 13:00-14:30, HU 204 Übungen beginnen am 10.04. Prüfung: (bei Prof. Dietzfelbinger) (Bachelor Informatik) Juli–Sept. 2012, 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 2 × pro Teilnehmer/in, nicht automatisch von 5,0 auf 4,0). FG KTuEA, TU Ilmenau Effiziente Algorithmen – Sommersemester 2012 7 Organistorisches Themen: 1. Divide-and-Conquer Multiplikation ganzer Zahlen: Algorithmus von Karatsuba Matrixmultiplikation: Algorithmus von Strassen Mergesort, exakte Analyse Rekurrenz(un)gleichungen, insbesondere: Master-Theorem Quicksort, neue Analyse Selection in Zeit O(n) – Algorithmus von BFPRT (Blum, Floyd, Pratt, Rivest, Tarjan) Schneller Selection-Algorithmus: Randomisiert Schnelle Fourier-Transformation FG KTuEA, TU Ilmenau Effiziente Algorithmen – Sommersemester 2012 8 Organistorisches 2. Durchsuchen und Strukturanalyse von Graphen Erinnerung: Breitensuche Erweiterte Tiefensuche (Kantenklassifikation) Kreisfreiheitstest, Finden von Kreisen Topologische Sortierung Starke Zusammenhangskomponenten Tiefensuche in ungerichteten Graphen mit Kreisfreiheitstest FG KTuEA, TU Ilmenau Effiziente Algorithmen – Sommersemester 2012 9 Organistorisches 3. Greedy-Strategie allgemein Teilbares Rucksackproblem Schedulingprobleme Kürzeste Wege 1: Algorithmus von Dijkstra Adressierbare Priority-Queues mittels binärer Heaps Huffman-Kodierung Set Cover FG KTuEA, TU Ilmenau Effiziente Algorithmen – Sommersemester 2012 10 Organistorisches 4. Minimale Spannbäume: Greedy-Strategien, Hilfsstrukturen Union-Find-Datenstruktur MST: Schnitteigenschaft MST: Algorithmus von Kruskal MST: Algorithmus von Prim Minimale Schnitte FG KTuEA, TU Ilmenau Effiziente Algorithmen – Sommersemester 2012 11 Organistorisches 5. Dynamische Programmierung Editierdistanz Matrix-Ketten-Multiplikation Ganzzahliges Rucksackproblem Kürzeste Wege 2: Algorithmus von Floyd-Warshall, Transitive Hülle Kürzeste Wege 3: Algorithmus von Bellman-Ford FG KTuEA, TU Ilmenau Effiziente Algorithmen – Sommersemester 2012 12 Kapitel 1 Divide-and-Conquer 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| ≤ n0 (Größenschranke): löse P auf x direkt“. ” Sonst: Gewinne aus x Teilinstanzen y1 , . . . , ya ( teile“). ” Rufe A rekursiv für y1 , . . . , ya auf, mit Lösungen r1 , . . . , ra . Gewinne aus x, y1 , . . . , ya , r1 , . . . , ra eine Lösung r des Problems P für Instanz x ( kombiniere“). ” FG KTuEA, TU Ilmenau Effiziente Algorithmen – Sommersemester 2012 14 Kapitel 1 Divide-and-Conquer Standardbeispiele aus AuD für D-a-C-Algorithmen: Mergesort Quicksort Binäre Suche (Details in der AuD-Vorlesung.) FG KTuEA, TU Ilmenau Effiziente Algorithmen – Sommersemester 2012 15 Kapitel 1 Divide-and-Conquer Multiplikation ganzer Zahlen 1.1 Multiplikation ganzer Zahlen Zahlen in Binärdarstellung. (Methoden funktionieren im Prinzip für jede beliebige Basis.) Bekannt: Volladdierer (5 Bitoperationen) liefert zu 3 Bits d, e, f die zwei Bits (s, c) = fulladd(d, e, f ) mit s = d ⊕ e ⊕ f (Summenbit) und c = (d ∧ e) ∨ (e ∧ f ) ∨ (f ∧ d) (Übertragsbit, Carry). FG KTuEA, TU Ilmenau Effiziente Algorithmen – Sommersemester 2012 16 Kapitel 1 Divide-and-Conquer Multiplikation ganzer Zahlen Bekannt: Serielle Binäraddition. Input: Binärzahlen/-strings an−1 . . . a0 und bn−1 . . . b0 c0 ← 0; (∗ Carry, Übertrag ∗) for i from 0 to n − 1 do (si , ci+1 ) ← fulladd(ai , bi , ci ); sn ← cn ; Ergebnis: sn . . . s0 . Kosten: Nicht mehr als 5n = O(n) Bitoperationen. Bekannt: Negative Zahlen, Subtraktion. Ganze Zahlen werden als Paar (Vorzeichen, Betrag) dargestellt, z. B. 10, −1001, 101010, −11110. Additionen und Subtraktionen solcher Zahlen mit der Zweierkomplementdarstellung auf die Addition zurückführbar. Kosten: nicht mehr als 6n Bitoperationen. FG KTuEA, TU Ilmenau Effiziente Algorithmen – Sommersemester 2012 17 Kapitel 1 Divide-and-Conquer Multiplikation ganzer Zahlen Multiplikation zweier natürlicher Zahlen Schulmethode“ ” 1 0 0 1 1 0 1 Überträge: Produkt: FG KTuEA, TU Ilmenau 0 1 0 0 0 · 1 1 0 0 1 1 : 1 0 0 0 1 1 0 0 1 0 1 0 0 0 1 0 0 0 0 0 0 0 1 0 0 1 1 0 1 0 0 0 1 10 1 0 1 1 0 0 0 1 1 1 1 0 0 1 0 0 1 0 Effiziente Algorithmen – Sommersemester 2012 18 Kapitel 1 Divide-and-Conquer Multiplikation ganzer Zahlen Allgemein: Input: Binärzahlen/-strings an−1 . . . a0 und bn−1 . . . b0 Bilde n Binärzahlen d (0) , . . . , d (n−1) : d (i) = (an−1 · bi ) . . . (a0 · bi ) 0 . . . 0 ! "# $ i Nullen und addiere alle diese. ≤ n − 1 Additionen von Zahlen mit nicht mehr als 2n Bits: O(n2 ) Bitoperationen. Geht es billiger? FG KTuEA, TU Ilmenau Effiziente Algorithmen – Sommersemester 2012 19 Kapitel 1 Divide-and-Conquer Multiplikation ganzer Zahlen Multiplikation mit Divide-and-Conquer-Strategie: Eingabe: n-Bit-Binärzahlen x und y , eventuell Vorzeichen. Falls n ≤ n0 : Benutze Schulmethode. Falls n > n0 : Setze k = )n/2*. Schreibe x = xn−1 . . . xk xk−1 . . . x0 ! "# $ ! "# $ A B und y = yn−1 . . . yk yk−1 . . . y0 ! "# $ ! "# $ C D Teile“! ” Dann x = A · 2k + B und y = C · 2k + D. x · y = (A · 2k + B)(C · 2k + D) = AC · 22k + (AD + BC ) · 2k + BD. FG KTuEA, TU Ilmenau Effiziente Algorithmen – Sommersemester 2012 20 Kapitel 1 Divide-and-Conquer Multiplikation ganzer Zahlen Erste Idee: Berechne rekursiv AC , AD, BC , BD, und füge die Produkte durch einige Additionen zum Resultat x · y zusammen. Kosten für n-Bit-Zahlen (für eine Konstante c): C (n) ≤ % 1 4 · C (n/2) + c · n für n = 1 für n > 1. (1) Man kann zeigen (später: Master-Theorem“): ” Die Anzahl der Bitoperationen ist wieder Θ(n2 ), nicht besser als Schulmethode. FG KTuEA, TU Ilmenau Effiziente Algorithmen – Sommersemester 2012 21 Kapitel 1 Divide-and-Conquer Multiplikation ganzer Zahlen x · y = (A · 2k + B)(C · 2k + D) = AC · 22k + (AD + BC ) · 2k + BD. Trick: E := A − B und F := C − D (sieht sinnlos aus . . . ) Bemerke: |E | und |F | haben als Betrag der Differenz von zwei nichtnegativen k-Bit-Zahlen höchstens k Bits. Nun: E · F = (A − B)(C − D) = AC + BD − (AD + BC ). Also: AD + BC = AC + BD − EF . x · y = AC · 22k + (AC + BD − EF ) · 2k + BD. FG KTuEA, TU Ilmenau Effiziente Algorithmen – Sommersemester 2012 22 Kapitel 1 Divide-and-Conquer Multiplikation ganzer Zahlen Algorithmus Ka (Algorithmus von Karatsuba) Eingabe: Zwei n-Bit-Zahlen x und y . if n ≤ n0 then return SM(x, y ) (∗ Schulmethode ∗) else k := )n/2*; zerlege x = A · 2k + B und y = C · 2k + 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 · 22k + (G + H − sign(E ) · sign(F ) · I ) · 2k + H. Dabei ist sign(a) das Vorzeichen von a. FG KTuEA, TU Ilmenau Effiziente Algorithmen – Sommersemester 2012 23 Kapitel 1 Divide-and-Conquer Multiplikation ganzer Zahlen Beispiel: Mit Dezimalzahlen, n0 = 2. (Methode funktioniert zu jeder Basis.) In der Informatik interessante Basiszahlen: 2, 8, 10, 16, 256, 216 , 232 , . . . 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 – Sommersemester 2012 24 Kapitel 1 Divide-and-Conquer Multiplikation ganzer Zahlen Weil z.B. n0 = 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 · 104 + (2660 + 98 − 891) · 102 + 98 = 26786798. Analog, rekursiv: H = BD = 03447540, I = |E | · |F | = 44679248. Ergebnis: x · y = 26786798 · 108 + (26786798 + 03447540 − (−1) · 44679248) · 104 + 03447540 = 2679428939307540 Beim Kombinationsschritt gibt es nur Additionen! FG KTuEA, TU Ilmenau Effiziente Algorithmen – Sommersemester 2012 25 Kapitel 1 Divide-and-Conquer Multiplikation ganzer Zahlen Für Input der Größe n > n0 müssen wir (rekursiv) a = 3 Teilprobleme für die Parametergröße )n/b* = )n/2*, also b = 2, lösen: rekursiv AC , BD, EF berechnen und müssen einige Additionen und Subtraktionen von Zahlen mit maximal 2n Bits durchführen: Zusätzlich O(n) Bitoperationen. FG KTuEA, TU Ilmenau Effiziente Algorithmen – Sommersemester 2012 26 Kapitel 1 Divide-and-Conquer Multiplikation ganzer Zahlen Einfachst-Analyse: Es sei n0 = 1 und n sei eine Zweierpotenz: n = 2! . MKa (n) = Anzahl der Bit-Multiplikationen (∧-Operationen). TKa (n) = Anzahl der Bit-Operationen. TKa (n0 ) = 1 und TKa (n) ≤ 3TKa (n/2) + cn, wobei c konstant ist. MKa (n0 ) = 1 und MKa (n) = 3MKa (n/2). Die zweite Rekurrenz-Gleichung ist einfacher. Achtung: Bitmultiplikationen gibt es nur auf dem untersten Rekursionslevel. FG KTuEA, TU Ilmenau Effiziente Algorithmen – Sommersemester 2012 27 Kapitel 1 Divide-and-Conquer Multiplikation ganzer Zahlen MKa (n0 ) = 1 und MKa (n) = 3 · MKa (n/2). MKa (2! ) = 3 · MKa (2!−1 ) = 32 · MKa (2!−2 ) = 33 · MKa (2!−3 ) .. . = 3! · MKa (2!−! ) = 3! · MKa (n0 ) = 3! . Beachte: 3! = (2log2 3 )! = (2! log2 3 ) = (2! )log2 3 = nlog2 3 . Dabei ist log2 3 ≈ 1,58496. Deutlich kleiner als n2 ! FG KTuEA, TU Ilmenau Effiziente Algorithmen – Sommersemester 2012 28 Kapitel 1 Divide-and-Conquer Multiplikation ganzer Zahlen TKa (n0 ) = 1 und TKa (n) ≤ 3TKa (n/2) + cn, wobei c konstant. TKa (2! ) ≤ ≤ 3 · (3 · TKa (2!−2 ) + c · 2!−1 ) + c · 2! ≤ .. . 33 · TKa (2!−3 ) + c · 32 · 2!−2 + c · 3 · 2!−1 + c · 2! = ≤ FG KTuEA, TU Ilmenau 3 · TKa (2!−1 ) + c · 2! 32 · TKa (2!−2 ) + c · 3 · 2!−1 + c · 2! ! 0 3 · TKa (2 ) + c · & 3j 2!−j 0≤j<! Effiziente Algorithmen – Sommersemester 2012 29 Kapitel 1 Divide-and-Conquer ! TKa (2 ) ≤ ≤ = < = Also: Multiplikation ganzer Zahlen 0 ! 3 · TKa (2 ) + c · & 3j 2!−j 0≤j≤!−1 ) * !−j & 2 3! · 1 + c · 3 0≤j≤!−1 . 2 ! 1 − ( 2 ! 3) 3 · 1+c · · 3 1 − 23 . 2 1 ! 3 · 1+c · · 1 3 3 3! · (1 + 2c). T (n) ≤ (1 + 2c)nlog2 3 = O(n1,585 ). FG KTuEA, TU Ilmenau Effiziente Algorithmen – Sommersemester 2012 30 Kapitel 1 Divide-and-Conquer Multiplikation ganzer Zahlen Satz 1.1.1 Beim Karatsuba-Multiplikationsalgorithmus beträgt die Anzahl der Bitoperationen und die Rechenzeit O(nlog2 3 ) = O(n1,585 ). In der Praxis (Implementierung in Software): Nicht n0 = 1 wählen, sondern für Zahlen einer Länge bis zur Wortgröße des Rechners (z. B. w = 32) die eingebaute Multiplikations-Hardware benutzen, d. h. mit Basis 2w rechnen. Für Zahlen bis zu einer Länge von n0 Worten: Schulmethode. Nur für längere Zahlen Karatsuba-Rekursion benutzen. Welches n0 optimal ist, hängt von der Hardware und eventuell von Programmierdetails ab. FG KTuEA, TU Ilmenau Effiziente Algorithmen – Sommersemester 2012 31 Kapitel 1 Divide-and-Conquer Multiplikation ganzer Zahlen Praxisbeispiel: GMP (GNU Multiple Precision Arithmetic Library) Nutzt 4 verschiedene Stufen: 1 Schulmethode Grenzen stark abhängig von der genutzten Architektur! 2 Karatsuba Atom-Prozessoren (x86) 3 TOOM33 (Knuth Abschnitt 4.3.3) 4 FFT-basierter Algorithmus Wechsel der Methode, sobald Anzahl Maschinenwörtern der Eingabe unter bestimmte Grenze sinkt. FG KTuEA, TU Ilmenau 1 2 3 Karatsuba: 10 ≤ #Wörter ≤ 65 TOOM33: 66 ≤ #Wörter ≤ 3455 FFT: ≥ 3456 Wörter Effiziente Algorithmen – Sommersemester 2012 32 Kapitel 1 Divide-and-Conquer Multiplikation ganzer Zahlen Praxisbeispiel: GMP (GNU Multiple Precision Arithmetic Library) Nutzt 4 verschiedene Stufen: 1 Schulmethode Grenzen stark abhängig von der genutzten Architektur! 2 Karatsuba Core2-Prozessoren (x86 64) 3 TOOM33 (Knuth Abschnitt 4.3.3) 4 FFT-basierter Algorithmus Wechsel der Methode, sobald Anzahl Maschinenwörtern der Eingabe unter bestimmte Grenze sinkt. FG KTuEA, TU Ilmenau 1 2 3 Karatsuba: 23 ≤ #Wörter ≤ 64 TOOM33: 65 ≤ #Wörter ≤ 4735 FFT: ≥ 4736 Wörter Effiziente Algorithmen – Sommersemester 2012 32 Kapitel 1 Divide-and-Conquer Multiplikation ganzer Zahlen Beispiele: Zahlen mit 1024 Binärziffern haben gut 300 Dezimalziffern. (Will man mit so riesigen Zahlen rechnen?) Ja! – Kryptographie! Anzahl der Multiplikationen von 32-Bit-Zahlen: # (210 ) = 3!−5 · M # (25 ) = 35 = 243. MKa Ka Schulmethode: (2!−5 )2 = 1024 Multiplikationen. Zahlen mit 32768 Binärziffern haben etwa 9900 Dezimalziffern. # (215 ) = 315−5 · M # (25 ) = 310 = 59049. MKa Ka Schulmethode: (215−5 )2 = 220 Multiplikationen, mehr als 1 Million! Ersparnis: Faktor 18. FG KTuEA, TU Ilmenau Effiziente Algorithmen – Sommersemester 2012 33 Kapitel 1 Divide-and-Conquer Multiplikation ganzer Zahlen Geht es noch besser? Theoretisch ja, praktisch eigentlich kaum. Mitteilung: Schönhage-Strassen (1971): Multiplikation zweier n-Bit-Zahlen mit O(n log n log log n) Gattern. Arnold Schönhage und Volker Strassen: Schnelle Multiplikation großer Zahlen, Computing 7, 1971, Springer Verlag, S. 281–292 Fürer (2007), De et al. (2008): Multiplikation zweier n-Bit-Zahlen mit ∗ log O(n log n · 2 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 – Sommersemester 2012 34 Kapitel 1 Divide-and-Conquer Multiplikation ganzer Zahlen Dabei ist log∗ n definiert als die kleinste Zahl i mit log log . . . log n ≤ 1. ! "# $ i−mal ∗ Also: log 2 = 1, log∗ 4 = 2, log∗ 16 = 3, log∗ 65536 = 4, log∗ (265536 ) = 5, 65536 65536 log∗ (22 ) = 6, und 22 ist schon eine sehr große Zahl. (Leider sind beide Algorithmen in der Praxis nicht so sehr hilfreich.) FG KTuEA, TU Ilmenau Effiziente Algorithmen – Sommersemester 2012 35 Kapitel 1 Divide-and-Conquer Matrixmultiplikation 1.2 Matrixmultiplikation Es sei R irgendein Ring.1 A = (aij )1≤i,j≤n , B = (bij )1≤i,j≤n seien n × n-Matrizen über R. Aufgabe: Berechne C = A · B, d.h. C = (cij )1≤i,j≤n mit & cij = aik bkj . 1≤k≤n Naive Implementierung gemäß dieser Formel kostet: n3 Ring-Multiplikationen und n2 (n − 1) Ring-Additionen. Strassen (1969): Es geht mit weniger Multiplikationen! Ansatz: Divide-and-Conquer. 1 Man kann addieren, subtrahieren, multiplizieren. FG KTuEA, TU Ilmenau Effiziente Algorithmen – Sommersemester 2012 36 Kapitel 1 Divide-and-Conquer Matrixmultiplikation Wir nehmen an: n = 2! , Zweierpotenz. Eingabe: n × n-Matrizen A, B. Falls n ≤ n0 : Berechne A · B mit der direkten Methode. n03 Multiplikationen. Falls n > n0 : Zerlege A, B in jeweils 4 quadratische ( n2 × n2 )-Teilmatrizen: A= ) C E D F Dann (leicht zu sehen): A·B = FG KTuEA, TU Ilmenau ) * , B= CG + DK EG + FK ) G K H L CH + DL EH + FL Effiziente Algorithmen – Sommersemester 2012 * * 37 Kapitel 1 Divide-and-Conquer Matrixmultiplikation Suggeriert rekursiven Ansatz, in dem 8 Multiplikationen von ( n2 × n2 )-Teilmatrizen durchgeführt werden. Einfache Analyse ergibt: n3 Multiplikationen in R, kein Gewinn. (Unten: Mit Master-Theorem: O(n3 ).) FG KTuEA, TU Ilmenau Effiziente Algorithmen – Sommersemester 2012 38 Kapitel 1 Divide-and-Conquer Matrixmultiplikation Strassen-Trick: 7 Multiplikationen genügen. P1 P2 P3 P4 Dann: AB = = C (H − L) = (C + D)L = (E + F )G = F (K − G ) ) P5 = (C + F )(G + L) P6 = (D − F )(K + L) P7 = (C − E )(G + H) P5 + P4 − P2 + P6 P1 + P2 P3 + P4 P1 + P5 − P3 − P7 * Von Hand nachzukontrollieren! 18 Additionen. (Alternative Methode, etwas komplizierter: 15 Additionen.) FG KTuEA, TU Ilmenau Effiziente Algorithmen – Sommersemester 2012 39 Kapitel 1 Divide-and-Conquer Matrixmultiplikation Aufwandsanalyse (einfachst): Für n0 = 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! : M(2! ) = 7M(2!−1 ) = . . . = 7! M(1) = 7! . 7! = 2! log2 7 = nlog2 7 mit log2 7 ≈ 2,81. Aufwandsanalyse (etwas komplizierter): Ringadditionen. A(1) = 0; A(n) ≤ 7A(n/2) + cn2 (für eine Konstante c). Rechnung wie bei Zahlen-Multiplikation ergibt: FG KTuEA, TU Ilmenau Effiziente Algorithmen – Sommersemester 2012 40 Kapitel 1 Divide-and-Conquer Matrixmultiplikation A(2! ) ≤ 7 · A(2!−1 ) + c · (22 )! ≤ 72 · A(2!−2 ) + c · 7 · (22 )!−1 + c · (22 )! .. . & ! 0 ≤ 7 · A(2 ) + c · (22 /7)!−j ! "# $ 0≤j≤!−1 =0 & ! = 7 ·c · (22 /7)!−j 0≤j≤!−1 4 1 − (4/7)! 4 1 ! = 7 ·c · · < 7 · c · · 3 = (4c/3) · 7! . 7 1 − (4/7) 7 7 ! Wieder O(nlog2 7 )! Alternative: Master-Theorem. FG KTuEA, TU Ilmenau Effiziente Algorithmen – Sommersemester 2012 41
