Vorüberlegungen, Karatsuba, Strassen

Effiziente Algorithmen
Vorüberlegungen und Divide-and-Conquer-Algorithmen
Vorlesender: Martin Aumüller
(nach Folien von Prof. Martin Dietzfelbinger)
April 2012
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
1
Organistorisches
Hörer:
Informatikstudierende (Bachelor) im 4. Semester,
Mathematikstudierende, andere Fächer bei Bedarf
Material: Eigene Mitschrift
Folienkopien, Übungsblätter
auf der folgenden Webseite:
http://www.tu-ilmenau.de/iti/lehre/lehre-ss-2012/ea/
Zugang über die Institutsseite.
Stoff: Vorlesung + Übungsaufgaben.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
2
Organistorisches
Zur Arbeitsweise:
Der Stoff ist zu kompliziert und zu umfangreich, um durch reines
Zuhören verstanden zu werden.
Regelmäßig Vorlesung nacharbeiten. Semesterbegleitend!
Begleitend Bücher ansehen.
Übungsblätter drucken, lesen, zur Übung mitbringen,
vorher Lösung ausdenken, Lösungsweg aufschreiben, an Lösungen
mitarbeiten, Lösungen vortragen.
Regelmäßig Übungen nacharbeiten. Semesterbegleitend!
Bei Verständnisproblemen frü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/Übung
Zeitaufwand: 3 – 3 12 Zeitstunden pro Woche
neben Vorlesung + Übung!
ergibt: 90 Stunden
plus 30 Stunden Prüfungsvorbereitung!
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
4
Organistorisches
Literaturvorschlä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
Literaturvorschläge:
T. Ottmann, P. Widmayer, Algorithmen und Datenstrukturen,
Spektrum Akademischer Verlag, 2002
U. Schö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
Ü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
Übungen beginnen am 10.04.
Prüfung: (bei Prof. Dietzfelbinger)
(Bachelor Informatik) Juli–Sept. 2012, 15–20 Min. mündlich
(andere) nach Vereinbarung, mündlich.
Bonuspunkte:
Korrektes Vorrechnen einer (markierten) Ü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
Kürzeste Wege 1: Algorithmus von Dijkstra
Adressierbare Priority-Queues mittels binärer Heaps
Huffman-Kodierung
Set Cover
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
10
Organistorisches
4. Minimale Spannbä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
Kürzeste Wege 2:
Algorithmus von Floyd-Warshall, Transitive Hülle
Kü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 für ein Problem P:
Gegeben ist Instanz/Input/Eingabe x der Größe“ |x| = n.
”
Falls n = |x| ≤ n0 (Größenschranke): löse P auf x direkt“.
”
Sonst: Gewinne aus x Teilinstanzen y1 , . . . , ya ( teile“).
”
Rufe A rekursiv für y1 , . . . , ya auf, mit Lösungen r1 , . . . , ra .
Gewinne aus x, y1 , . . . , ya , r1 , . . . , ra eine Lösung r des Problems P für
Instanz x ( kombiniere“).
”
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
14
Kapitel 1 Divide-and-Conquer
Standardbeispiele aus AuD für D-a-C-Algorithmen:
Mergesort
Quicksort
Binä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 Binärdarstellung.
(Methoden funktionieren im Prinzip fü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) (Übertragsbit, Carry).
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
16
Kapitel 1 Divide-and-Conquer
Multiplikation ganzer Zahlen
Bekannt: Serielle Binäraddition.
Input: Binärzahlen/-strings an−1 . . . a0 und bn−1 . . . b0
c0 ← 0; (∗ Carry, Ü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 zurückfü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 natürlicher Zahlen
Schulmethode“
”
1 0 0 1 1 0
1
Überträ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: Binärzahlen/-strings an−1 . . . a0 und bn−1 . . . b0
Bilde n Binä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-Binä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 füge die Produkte durch einige Additionen zum Resultat x · y
zusammen.
Kosten für n-Bit-Zahlen (für eine Konstante c):
C (n) ≤
%
1
4 · C (n/2) + c · n
für n = 1
für n > 1.
(1)
Man kann zeigen (spä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 hö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 aufgefü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 fü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
Für Input der Größe n > n0 müssen wir (rekursiv) a = 3 Teilprobleme für
die Parametergröße )n/b* = )n/2*, also b = 2, lösen:
rekursiv AC , BD, EF berechnen
und müssen einige Additionen und Subtraktionen von Zahlen mit maximal
2n Bits durchführen:
Zusä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 beträgt die Anzahl der
Bitoperationen und die Rechenzeit O(nlog2 3 ) = O(n1,585 ).
In der Praxis (Implementierung in Software):
Nicht n0 = 1 wählen, sondern für Zahlen einer Länge bis zur Wortgröße
des Rechners (z. B. w = 32) die eingebaute Multiplikations-Hardware
benutzen, d. h. mit Basis 2w rechnen.
Für Zahlen bis zu einer Länge von n0 Worten: Schulmethode.
Nur für längere Zahlen Karatsuba-Rekursion benutzen. Welches n0 optimal
ist, hä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 abhä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
Maschinenwörtern der Eingabe unter
bestimmte Grenze sinkt.
FG KTuEA, TU Ilmenau
1
2
3
Karatsuba:
10 ≤ #Wörter ≤ 65
TOOM33:
66 ≤ #Wörter ≤ 3455
FFT: ≥ 3456 Wö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 abhä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
Maschinenwörtern der Eingabe unter
bestimmte Grenze sinkt.
FG KTuEA, TU Ilmenau
1
2
3
Karatsuba:
23 ≤ #Wörter ≤ 64
TOOM33:
65 ≤ #Wörter ≤ 4735
FFT: ≥ 4736 Wörter
Effiziente Algorithmen – Sommersemester 2012
32
Kapitel 1 Divide-and-Conquer
Multiplikation ganzer Zahlen
Beispiele:
Zahlen mit 1024 Binä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 Binä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:
Schönhage-Strassen (1971): Multiplikation zweier n-Bit-Zahlen mit
O(n log n log log n) Gattern.
Arnold Schönhage und Volker Strassen: Schnelle Multiplikation großer
Zahlen, Computing 7, 1971, Springer Verlag, S. 281–292
Fürer (2007), De et al. (2008): Multiplikation zweier n-Bit-Zahlen mit
∗
log
O(n log n · 2 n ) Gattern.
Martin Fü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 über R.
Aufgabe: Berechne C = A · B, d.h. C = (cij )1≤i,j≤n mit
&
cij =
aik bkj .
1≤k≤n
Naive Implementierung gemäß 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 durchgefü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 genü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):
Für n0 = 1, M(n) = Anzahl der Ringmultiplikationen.
(Nur im Basisfall der Rekursion!)
M(1) = 1;
M(n) = 7M(n/2) für n > 1.
Fü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 (fü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