Vorüberlegungen und Divide-and-Conquer-Algorithmen

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
Organisatorisches
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
Organisatorisches
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
Organisatorisches
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
Organisatorisches
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
Organisatorisches
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
Organisatorisches
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
Organisatorisches
Themen:
1. Divide-and-Conquer
Multiplikation ganzer Zahlen: Algorithmus von Karatsuba
Matrixmultiplikation: Algorithmus von Strassen
Mergesort, exakte Analyse
Rekurrenz(un)gleichungen, insbesondere: Master-Theorem
Quicksort, neue Analyse
Selection in Zeit O(n) – Algorithmus von BFPRT
(Blum, Floyd, Pratt, Rivest, Tarjan)
Schneller Selection-Algorithmus: Randomisiert
Schnelle Fourier-Transformation
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
8
Organisatorisches
2. Durchsuchen und Strukturanalyse von Graphen
Erinnerung: Breitensuche
Erweiterte Tiefensuche (Kantenklassifikation)
Kreisfreiheitstest, Finden von Kreisen
Topologische Sortierung
Starke Zusammenhangskomponenten
Tiefensuche in ungerichteten Graphen mit Kreisfreiheitstest
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
9
Organisatorisches
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
Organisatorisches
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
Organisatorisches
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
| {z }
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 = dn/2e.
Schreibe x = xn−1 . . . xk xk−1 . . . x0
| {z } | {z }
A
B
und y = yn−1 . . . yk yk−1 . . . y0
| {z } | {z }
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 := dn/2e;
zerlege x = A · 2k + B und y = C · 2k + D;
E := A − B und F := C − D; (∗ auf dn/2e 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 dn/be = dn/2e, 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 · TKa (2`−1 ) + c · 2`
≤
3 · (3 · TKa (2`−2 ) + c · 2`−1 ) + c · 2`
=
32 · TKa (2`−2 ) + c · 3 · 2`−1 + c · 2`
≤
..
.
33 · TKa (2`−3 ) + c · 32 · 2`−2 + c · 3 · 2`−1 + c · 2`
≤
`
0
3 · TKa (2 ) + c ·
X
3j 2`−j
0≤j<`
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
29
Kapitel 1 Divide-and-Conquer
`
TKa (2 ) ≤
`
Multiplikation ganzer Zahlen
0
3 · TKa (2 ) + c ·
X
3j 2`−j
0≤j≤`−1

`−j
X
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

≤
=
<
=
Also:
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
Karatsuba:
10 ≤ #Wörter ≤ 65
2
TOOM33:
66 ≤ #Wörter ≤ 3455
3
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
Karatsuba:
23 ≤ #Wörter ≤ 64
2
TOOM33:
65 ≤ #Wörter ≤ 4735
3
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:
0 (210 ) = 3`−5 · M 0 (25 ) = 35 = 243.
MKa
Ka
Schulmethode: (2`−5 )2 = 1024 Multiplikationen.
Zahlen mit 32768 Binärziffern haben etwa 9900 Dezimalziffern.
0 (215 ) = 315−5 · M 0 (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.
|
{z
}
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
X
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
,
B=
G
K
H
L
Dann (leicht zu sehen):
A·B =
FG KTuEA, TU Ilmenau
CG + DK
EG + FK
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:
= C (H − L)
= (C + D)L
= (E + F )G
= F (K − G )
AB =
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 )`
..
.


X
` 
0
≤ 7 · A(2 ) + c ·
(22 /7)`−j 
| {z }
0≤j≤`−1
=0


X
`
= 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
Kapitel 1 Divide-and-Conquer
Mergesort
1.3 Erinnerung: Mergesort
Um n Zahlen/Objekte a1 , . . . , an zu sortieren, geht der
Mergesort-Algorithmus so vor:
Falls n ≤ n0 :
Sortiere mit einem naiven Algorithmus (z. B. Insertion Sort).
Sonst: k := bn/2c.
Sortiere a1 , . . . , ak (erste Hälfte) rekursiv, Ergebnis b1 , . . . , bk ;
sortiere ak+1 , . . . , an (zweite Hälfte) rekursiv, Ergebnis bk+1 , . . . , bn .
Mische“ die Folgen b1 , . . . , bk und bk+1 , . . . , bn zu einer sortierten Folge
”
zusammen
Reißverschlussverfahren“ – Aufwand: ≤ n − 1 Vergleiche.
”
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
42
Kapitel 1 Divide-and-Conquer
Mergesort
Analyse über Rekurrenzungleichungen“:
”
Wir zä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 (bn/2c) + C (dn/2e) + n − 1.
Behauptung: C (n) = ndlog ne − (2dlog ne − 1).
n
C (n)
1
0
2
1
3
3
4
5
5
8
6
11
7
14
8
17
9
21
10
25
11
29
12
33
13
37
14
41
...
...
Beweis: Tafel.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
43
Kapitel 1 Divide-and-Conquer
Mergesort
Satz 1.3.1
Für die Vergleichsanzahl im schlechtesten Fall bei Mergesort gilt:
C (n) ≤ n log n.
Beweis: Tafel.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
44
Kapitel 1 Divide-and-Conquer
Master-Theorem
1.4 Das Master-Theorem
Wir betrachten Rekurrenzungleichungen der folgenden Form:
g
, falls n = 1
B(n) ≤
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(dn/be) denken.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
45
Kapitel 1 Divide-and-Conquer
Master-Theorem
Ergibt sich bei Divide-and-Conquer-Algorithmus mit:
Trivialer Basisfall (Größe 1) hat höchstens Kosten g ,
aus Instanz der Größe n > 1 werden ( divide“) a Teilinstanzen der Größe
”
n/b (passend gerundet) gebildet,
es erfolgen a rekursive Aufrufe,
und die a Lösungen werden kombiniert.
Kosten fü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 erfüllt die Rekurrenzungleichung.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
46
Kapitel 1 Divide-and-Conquer
Master-Theorem
Vereinfachende Annahmen (nicht wesentlich):
n = b` .
b > 1 ist ganzzahlig.
Level 0: Wurzel, hat Eintrag f (n) und hat a Kinder auf Level 1.
Knoten v auf Level i < ` hat Eintrag f (n/b i ) und hat a Kinder auf Level
i + 1.
Knoten auf Level ` sind Blätter, sie haben Eintrag g .
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
47
Kapitel 1 Divide-and-Conquer
Master-Theorem
f (n)
f (n)
a
f (n/b)
a · f (n/b)
f (n/b)
a
f (n/b 2 )
f (n/b 2 )
f (n/b 2 )
f (n/b 2 )
a2 · f (n/b 2 )
`
g
g
g
g
g
g
g
FG KTuEA, TU Ilmenau
g
g
g
g
g
g
g
g
g
g
g
g
g
g
g
g
g
g
g
Effiziente Algorithmen – Sommersemester 2012
g
g
g
g
g
g
a` · g
48
Kapitel 1 Divide-and-Conquer
Master-Theorem
Lemma 1.4.1
Wenn v ein Knoten auf Level i ist, dann gilt:
B(n/b i ) ≤ Summe der Einträge im Unterbaum unter v .
(Beweis durch Induktion über ` − i.)
Also: B(n) ≤ Summe aller Einträge im Baum.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
49
Kapitel 1 Divide-and-Conquer
Master-Theorem
Auf Level i gibt es ai Knoten mit Eintrag f (n/b i ).
Summation liefert:
B(n) ≤
X
ai · f (n/b i ) + a` · g .
0≤i<`
Erster Term B1 : Beitrag zu Gesamtkosten aus dem Inneren des Baums.
Zweiter Term B2 : Beitrag von den Blättern.
(Algorithmisch: Die a` Basisfälle.) – Leicht:
B2 (n) = a` · g = (b logb a )` · g = (b ` )logb a · g = nlogb a · g .
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
50
Kapitel 1 Divide-and-Conquer
Erster Term: B1 (n) =
P
0≤i<` a
i
Master-Theorem
· f (n/b i ).
3 Fälle, je nach Verhalten des Gesamtaufwandes ai · f (n/b i ) auf Level i,
für i = 0, . . . , ` − 1.
Intuitiv:
1. Fall: ai · f (n/b i ) wächst mit i an.
2. Fall: ai · f (n/b i ) bleibt in etwa gleich über alle i.
3. Fall: ai · f (n/b i ) schrumpft mit i.
Genaueres folgt.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
51
Kapitel 1 Divide-and-Conquer
Master-Theorem
1. Fall: f (n) = O(nα ) mit b α < a.
Die Beiträge aus den unteren Baumebenen (kleine Instanzen) dominieren,
nicht wegen ihrer Größe, sondern wegen ihrer Anzahl.
f (n)
f (n/b)
f (n/b 2 )
f (n/b 2 )
f (n/b 2 )
f (n/b)
f (n/b 2 )
f (n/b 2 )
f (n/b)
f (n/b 2 )
f (n/b 2 )
f (n/b 2 )
f (n/b 2 )
g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
52
Kapitel 1 Divide-and-Conquer
Master-Theorem
Wir benutzen immer die Summenformel für geometrische Reihen:
(∗)
X
0≤i<`
FG KTuEA, TU Ilmenau
`−1
q
qi =
, für q ≥ 0, q 6= 1.
q−1
Effiziente Algorithmen – Sommersemester 2012
53
Kapitel 1 Divide-and-Conquer
B1 (n) =
X
Master-Theorem
ai · f (n/b i )
0≤i<`
=O
X
ai ·
n α bi
0≤i<`
X a i = O nα ·
bα
0≤i<`
α
`
(a/b )
α
=O n ·
(a/b α ) − 1
1
α
`
=O n ·a · ` α
(b )
= O(a` ).
Also: B(n) ≤ B1 (n) + B2 (n) = O(a` ) = O(nlogb a ).
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
54
Kapitel 1 Divide-and-Conquer
Master-Theorem
1. Fall: f (n) = O(nα ) mit b α < a.
Typische Beispiele:
Karatsuba-Algorithmus, Strassen-Algorithmus.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
55
Kapitel 1 Divide-and-Conquer
Master-Theorem
2. Fall: f (n) = O(nlogb a ).
f (n/b i ) wächst mit n/b i , i = ` − 1, . . . , 0, höchstens mit einer Rate, die
durch das Schrumpfen der Größe der Baumebene ausgeglichen wird.
Der Gesamtaufwand ist beschränkt durch den Aufwand für die Ebene
direkt über den Blättern, multipliziert mit der Anzahl der Levels.
f (n)
f (n/b)
f (n/b)
f (n/b 2 )
g
g
g
g
FG KTuEA, TU Ilmenau
g
f (n/b 2 )
g
g
g
g
g
g
g
g
f (n/b 2 )
g
g
g
g
g
g
g
g
f (n/b 2 )
g
g
g
Effiziente Algorithmen – Sommersemester 2012
g
g
g
g
g
g
g
g
56
Kapitel 1 Divide-and-Conquer
B1 (n) =
X
Master-Theorem
ai · f (n/b i )
0≤i<`

=O

X
ai ·
0≤i<`
n logb a

bi


logb a
n

=O
a ·
ai
0≤i<`
= O ` · nlogb a .
X
i
Also:
B(n) ≤ B1 (n) + B2 (n) = O(` · nlogb a ) + O(nlogb a ) = O((log n) · nlogb a ).
Typische Beispiele: Mergesort, Binäre Suche.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
57
Kapitel 1 Divide-and-Conquer
Master-Theorem
3. Fall: f (n) = Ω(nα ), mit b α > a
UND
(Regularitätsbedingung:
f wächst stets mit der entsprechenden Rate)
Es gibt ein c < 1 mit: f (n) ≥ (a/c) · f (n/b).
Wenn man die Größe des Inputs von n/b auf n erhöht, wachsen die Kosten
im Knoten von f (n/b) auf f (n), mindestens um den Faktor a/c > a.
f (n) wächst sehr rasch mit n, so dass der Beitrag der oberen Baumebenen
und insbesondere der Wurzel überwiegt.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
58
Kapitel 1 Divide-and-Conquer
Master-Theorem
f (n)
f (n/b)
f (n/b 2 )
FG KTuEA, TU Ilmenau
f (n/b)
f (n/b 2 )
f (n/b 2 )
Effiziente Algorithmen – Sommersemester 2012
f (n/b 2 )
59
Kapitel 1 Divide-and-Conquer
Master-Theorem
Aus der Regularitätsbedingung gewinnen wir:
c
f (n/b) ≤ · f (n)
a
c 2
f (n/b 2 ) ≤
· f (n)
a
..
.
c i
f (n/b i ) ≤
· f (n) , also:
a
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
60
Kapitel 1 Divide-and-Conquer
B1 (n) =
X
Master-Theorem
ai · f (n/b i )
0≤i<`
≤
X
i
a ·
c i
0≤i<`
=
X
a
· f (n)
c i · f (n)
0≤i<`
= f (n) ·
X
ci
0≤i<`
= O(f (n)),
weil
P
0≤i<`
ci
FG KTuEA, TU Ilmenau
=
1−c `
1−c
= O(1).
Effiziente Algorithmen – Sommersemester 2012
61
Kapitel 1 Divide-and-Conquer
Master-Theorem
Satz 1.4.2 (Das Master-Theorem)
g
, falls n = 1
Es gelte B(n) ≤
a · B(n/b) + f (n) , sonst,
wobei b > 1 und a ganzzahlige Konstante sind.
Dann gilt für n = b ` :
1
2
3
Falls f (n) = O(nα ) mit α < logb a, dann ist
B(n) = O(nlogb a ).
Falls f (n) = O(nlogb a ), dann ist B(n) = O(nlogb a · log n).
Falls f (n) = Ω(nα ) mit α > logb a und f (n) ≥
konstant, dann ist B(n) = O(f (n)).
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
a
c
· f (n/b), für c < 1
62
Kapitel 1 Divide-and-Conquer
Master-Theorem
Erweiterungen: Dieselben Formeln gelten für:
Beliebige n, nicht nur n = b ` .
Verallgemeinerte Relation
B(n) ≤ a · B(n0 ) + f (n), n0 ≤ dn/be + d.
b > 1 nicht ganzzahlig.
Analoge untere Schranken.
Genaueres im Buch von Cormen, Leiserson, Rivest und Stein.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
63
Kapitel 1 Divide-and-Conquer
Quicksort
1.5 Quicksort (Hoare1 ) – Neue Analyse
Input: Folge/Array (a1 , . . . , an ). – Falls n = 1, Ausgabe (a1 ).
Falls n = 2, sortiere mit einem Vergleich. – Sonst:
Wähle Element x ∈ {a1 , . . . , an } als Pivotelement“ oder
”
partitionierendes Element“.
”
(Z.B.: x = a1 oder x = ai mit i zufällig.)
Zerlege (a1 , . . . , an ) in eine Teilfolge b1 , . . . , bp−1 , alle ≤ x, in das Element
x, und eine Teilfolge cp+1 , . . . , cn , alle ≥ x.
Sortiere diese beiden Folgen rekursiv,
Ergebnis (d1 , . . . , dp−1 ) und (ep+1 , . . . , en ).
Ausgabe: Folge/Array (d1 , . . . , dp−1 , x, ep+1 , . . . , en ).
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
64
Kapitel 1 Divide-and-Conquer
Quicksort
C. A. R. Hoare (∗ 1934), brit. Informatiker,
erfand Quicksort & Korrektheitskalkül.
1
I conclude that there are two ways of constructing a software design: One
”
way is to make it so simple that there are obviously no deficiencies and the
other way is to make it so complicated that there are no obvious
deficiencies. The first method is far more difficult.“
(Dankesrede für den Turingpreis 1980)
I think Quicksort is the only really interesting algorithm that I’ve ever
”
developed.“
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
65
Kapitel 1 Divide-and-Conquer
Quicksort
Analyse: Wir nehmen an, alle Schlüssel sind verschieden. Wir wählen
immer das erste Element als Pivotelement – betrachten also
deterministisches Quicksort.
Weiter nehmen wir an, jede der n! Anordnungen sind gleich wahrscheinlich
(Wahrscheinlichkeit 1/n!),
und berechnen die erwartete Anzahl A(n) von Vergleichen.
Falls n ≤ 1: kein Vergleich. Falls n = 2: 1 Vergleich. – Sonst:
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
66
Kapitel 1 Divide-and-Conquer
Quicksort
Es seien b1 < · · · < bn die Eingabe-Elemente in sortierter Reihenfolge.
Es ist klar, dass bi und bj maximal einmal miteinander verglichen werden.
(Wenn bi und bj verglichen werden, ist eines der beiden Pivotelement und
wird nie mehr mit etwas anderem verglichen.)
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
67
Kapitel 1 Divide-and-Conquer
Quicksort
C := Gesamtanzahl der Vergleiche.
(Zufallsvariable, abhängig von der zufälligen Anordnung am Anfang.)
Sei
C=
X
Xij ,
1≤i<j≤n
wobei
Xij =
FG KTuEA, TU Ilmenau
1
0
, falls bi und bj verglichen werden
, sonst.
Effiziente Algorithmen – Sommersemester 2012
68
Kapitel 1 Divide-and-Conquer
Quicksort
Daraus:
E(C ) =
X
E(Xij ) =
1≤i<j≤n
X
Pr(Xij = 1).
1≤i<j≤n
(Das folgt aus der Linearität des Erwartungswertes, normalerweise
geschrieben als E(X + Y ) = E(X ) + E(Y ).)
Was ist Pr(Xij = 1) = Pr(bi und bj werden verglichen)?
Wir beobachten den Algorithmus.
Klar: Im Zuge der Rekursion werden durch Aufspalten immer kleinere
Teillisten gebildet.
Solange kein Element von Iij = {bi , bi+1 , . . . , bj } Pivotelement wird,
landen alle Elemente von Iij immer in derselben Teilliste (alle größer als
Pivot oder alle kleiner als Pivot).
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
69
Kapitel 1 Divide-and-Conquer
Quicksort
In dem Moment, in dem zum ersten Mal ein Element von Iij
partitionierendes Element wird, fällt die Entscheidung:
Wenn dies bi oder bj ist, werden bi und bj verglichen.
Wenn dies ein Element von {bi+1 , . . . , bj−1 } ist, nicht
(jetzt nicht, aber auch nicht später, da sie in verschiedenen Teillisten
landen).
Weil alle Elemente in Iij die gleiche Wahrscheinlichkeit haben, zuerst als
Pivotelement gewählt zu werden, gilt
2
2
Pr(bi und bj werden verglichen) =
=
.
|Iij |
j −i +1
Also:
E(C ) =
X
1≤i<j≤n
FG KTuEA, TU Ilmenau
2
.
j −i +1
Effiziente Algorithmen – Sommersemester 2012
70
Kapitel 1 Divide-and-Conquer
X
1≤i<j≤n
Quicksort
X X
2
2
=
j −i +1
j −i +1
1≤i≤n i<j≤n
=2·
X
X
1≤i≤n 2≤k≤n−i+1
≤2·
X
1
k
X 1
k
1≤i≤n 2≤k≤n
= 2 · n · (Hn − 1)
≤ 2 · n · ln n
= (2 ln 2) · n · log n
< 1,3863n log n.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
71
Kapitel 1 Divide-and-Conquer
Dabei ist Hn = 1 + 12 + · · · +
(n-te harmonische Zahl).
1
n
Quicksort
∈ [ln n + 12 , ln n + 1]
Satz 1.5.1
Die durchschnittliche Anzahl von Vergleichen von Quicksort auf einer
Eingabe aus n verschiedenen Zahlen, die zufällig angeordnet ist, ist
höchstens
2 · n · (Hn − 1) < 1,3863n log n.
Für die, die es genau wissen wollen:
E(C ) = 2(n + 1)Hn − 4n = (2 log2 e)n log n − Θ(n).
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
72
Kapitel 1 Divide-and-Conquer
Quicksort
Variation: Randomisiertes Quicksort“.
”
Das Pivotelement wird jeweils zufällig gewählt.
In diesem Fall ist die gleiche Analyse anwendbar.
Aber: Es gibt keine worst-case-Inputs mehr.
Satz 1.5.2
Wenn man das Pivot-Element stets zufällig wählt, ist auf einer beliebigen,
festen Eingabe aus n verschiedenen Zahlen die erwartete Anzahl von
Vergleichen, die Quicksort ausführt, höchstens
2 · n · (Hn − 1) < 1,3863n log n.
(Siehe hierzu: Randomisierte Algorithmen“.)
”
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
73
Kapitel 1 Divide-and-Conquer
Selektionsproblem
1.6 Das Selektionsproblem
Gegeben ist eine Folge (a1 , . . . , an ) von n Objekten aus einer totalen
Ordnung (D, <) (in Array oder als Liste),
sowie eine Zahl k, 1 ≤ k ≤ n.
O.B.d.A.: Alle Einträge verschieden.
Aufgabe
Finde das Element der Folge, das Rang k hat, d. h. ein Objekt x in der
Liste mit |{i | ai ≤ x}| = k.
Spezialfall: Der Median einer Folge mit n Einträgen ist das Element mit
Rang dn/2e. Median({2, 4, 7, 9}) = 4, Median({4, 7, 9}) = 7.
Einfache Lösung: Sortiere, mit Ergebnis (b1 , . . . , bn ), nun wähle x = bk . –
Kosten: n log n Vergleiche, Zeit O(n log n).
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
74
Kapitel 1 Divide-and-Conquer
Selektionsproblem
Zunächst:
Ein randomisierter Algorithmus für das Auswahlproblem.
Quickselect (Hoare)
Ansatz: Wie bei Quicksort.
Gegeben: Folge (a1 , . . . , an ), Zahl k, 1 ≤ k ≤ n.
O.B.d.A.: Die ai sind verschieden.
Falls n = 1, ist nichts zu tun.
Falls n = 2, sortiere mit einem Vergleich, Ergebnis (b1 , b2 ), gib Element bk
zurück.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
75
Kapitel 1 Divide-and-Conquer
Selektionsproblem
Falls n ≥ 3:
Wähle ein Element x aus {a1 , . . . , an } als partitionierendes Element
zufällig.
Zerlege (a1 , . . . , an ) mit n − 1 Vergleichen in eine Teilfolge b1 , . . . , bp−1 ,
alle < x, in das Element x, und eine Teilfolge cp+1 , . . . , cn , alle > x.
1. Fall: k = p. Das Ergebnis ist x.
2. Fall: k < p. Finde (rekursiv) in (b1 , . . . , bp−1 ) das Element vom Rang
k.
3. Fall: k > p. Finde (rekursiv) in (cp+1 , . . . , cn ) das Element vom Rang
k − p.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
76
Kapitel 1 Divide-and-Conquer
Selektionsproblem
Korrektheit: Klar.
Zu analysieren: (Erwartete) Rechenzeit.
Wir analysieren die erwartete Anzahl von Vergleichen.
Vorgehen: Wie bei Quicksort. Wieder ist die erwartete Anzahl von
Vergleichen entscheidend.
Eingabezahlen, sortiert: b1 < · · · < bn .
Ck =
X
Xij ,
1≤i<j≤n
wobei
Xij =
FG KTuEA, TU Ilmenau
1
0
, falls bi und bj verglichen werden
, sonst.
Effiziente Algorithmen – Sommersemester 2012
77
Kapitel 1 Divide-and-Conquer
Selektionsproblem
Was ist E(Xij ) = Pr(Xij = 1) = Pr(bi und bj werden verglichen)?
1. Fall: k ≤ i < j: Es kommt darauf an, ob bi oder bj vor allen anderen
Einträgen in {bk , . . . , bj } Pivot werden.
Pr(Xij = 1) =
2
j−k+1 .
2. Fall: i < k < j: Es kommt darauf an, ob bi oder bj vor allen anderen
Einträgen in {bi , . . . , bj } Pivot werden.
Pr(Xij = 1) =
2
j−i+1 .
3. Fall: i < j ≤ k: Es kommt darauf an, ob bi oder bj vor allen anderen
Einträgen in {bi , . . . , bk } Pivot werden.
Pr(Xij = 1) =
FG KTuEA, TU Ilmenau
2
k−i+1 .
Effiziente Algorithmen – Sommersemester 2012
78
Kapitel 1 Divide-and-Conquer
Selektionsproblem
Also:
!
E(Ck ) = 2 ·
P
k≤i<j≤n
1
j−k+1
P
+
1≤i<k<j≤n
1
j−i+1
+
P
1≤i<j≤k
1
k−i+1
.
Erste und dritte Summe lassen sich leicht als n − k bzw. k − 1 abschätzen
(Übung!).
Zusammen: 2(n − 1).
In der Übung zeigen wir:
P
1≤i<k<j≤n
1
j−i+1
≤ n.
Zusammen: E(Ck ) ≤ 4n.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
79
Kapitel 1 Divide-and-Conquer
Selektionsproblem
Es gilt:
X
k≤i<j≤n
1
=
j −k +1
n
X
j=k+1
j −k
<
j −k +1
n
X
1 = n − k.
j=k+1
Weiterhin gilt:
X
1≤i<j≤k
k−1
k−1
i=1
i=1
X k −i
X
1
=
<
1 = k − 1.
k −i +1
k −i +1
Die Terme der Summe
X
1≤i<k<j≤n
1
j −i +1
stellen wir in der nachfolgenden (k − 1) × (n − k)-Matrix dar (für k ≤ n/2):
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
80
Kapitel 1 Divide-and-Conquer
Selektionsproblem
X
1≤i<k<j≤n















1
k+1
1
k+2
...
...
1
n−k+1
1
j −i +1
1
n−k+2
1
n−k+3
...
1
n−1
1
n
1
k
1
k+1
1
k+2
...
...
1
n−k+1
1
n−k+2
...
1
n−2
1
n−1
..
.
..
.
..
..
..
..
..
..
..
.
..
.
1
4
1
5
...
1
k+1
1
k+2
...
...
1
n−k+1
1
n−k+2
1
n−k+3
1
3
1
4
...
1
k
1
k+1
1
k+2
...
...
1
n−k+1
1
n−k+2
FG KTuEA, TU Ilmenau
.
.
.
.
.
Effiziente Algorithmen – Sommersemester 2012
.















81
Kapitel 1 Divide-and-Conquer
Selektionsproblem
Wir summieren entlang der Diagonalen. Auffällig: Die Summe der
Elemente auf einer Diagonalen ist jeweils kleiner als 1. Es gibt maximal
k − 2 + n − k Diagonalen, also gilt:
X
1≤i<k<j≤n
1
< n − 2.
j −i +1
Anmerkung: Im Falle k > n/2 gilt das hier gebrachte Argument
nachwievor, die Matrix sieht schematisch aber etwas anders aus. Aus
Symmetriegründen (Ck = Cn−k+1 ) kann man jedoch auch ohne
Beschränkung der Allgemeinheit k ≤ n/2 annehmen.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
82
Kapitel 1 Divide-and-Conquer
Selektionsproblem
Satz 1.6.1
Der Algorithmus Quickselect löst das Auswahlproblem und hat eine
erwartete Vergleichsanzahl von ≤ 4n und eine erwartete Laufzeit von O(n).
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
83
Kapitel 1 Divide-and-Conquer
Selektionsproblem
Mitteilung:
(a) Eine genauere Analyse ergibt für α = k/n konstant eine erwartete
Vergleichsanzahl von 2(1 + H(α) ln 2 + o(1))n < (3.3863 + o(1)) · n.
Dabei ist H(α) = −α log α − (1 − α) log(1 − α)
die binäre Entropie“.
”
Sie liegt zwischen 0 und 1; das Maximum 1 ist bei α = 12 , was der Suche
nach dem Median entspricht.
(b) Die beste Schranke für die erwartete Vergleichsanzahl bei einem
Algorithmus für das Auswahlproblem, nämlich 23 n + o(n), erreicht ein
anderer randomisierter Algorithmus (siehe Vorlesung Randomisierte
”
Algorithmen“).
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
84
Kapitel 1 Divide-and-Conquer
Selektionsproblem
Nun:
Ziel: Ein deterministischer Algorithmus mit Aufwand O(n).
(Erfinder: M. Blum, R. W. Floyd, V. R. Pratt, R. L. Rivest, R. E. Tarjan:
lauter Pioniere der Algorithmik!)
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
85
Kapitel 1 Divide-and-Conquer
Selektionsproblem
Ansatz: Wie bei Quickselect:
Finde ein partitionierendes Element x.
Verschiebe, so dass alle Elemente < x links von x stehen, alle
Elemente > x rechts.
Bestimme, in welchem Teil das gesuchte Element vom Rang k ist.
Rufe den Algorithmus rekursiv auf diesem Teil auf.
Zentrales Problem
Wie kann man deterministisch ein günstiges“ Element x bestimmen?
”
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
86
Kapitel 1 Divide-and-Conquer
Selektionsproblem
Algorithmus BFPRT(a1 , . . . , an , k)
1
Falls n ≤ n0 : Sortiere mit Mergesort, fertig. Sonst:
2
Teile (a1 , . . . , an ) in m = dn/5e Gruppen mit 4 bzw. 5 Elementen auf.
3
Bestimme in jeder Gruppe den Median (Bsp: Mergesort).
∗ ) die Liste dieser Mediane.
Sei (a1∗ , . . . , am
4
∗ ).
Suche rekursiv mittels BFPRT nach dem Median x von (a1∗ , . . . , am
5
Zerlege (a1 , . . . , an ) in eine Teilfolge b1 , . . . , bp−1 , alle ≤ x, in das
Element x, und eine Teilfolge cp+1 , . . . , cn , alle ≥ x.
6
Falls k = p: Rückgabe x.
7
Falls k < p: BFPRT(b1 , . . . , bp−1 , k).
8
Falls k > p: BFPRT(cp+1 , . . . , cn , k − p).
In der Literatur bezeichnet man x als Median der Mediane“. Das Finden
”
eines partitionierenden Elements erfolgt in den Schritten 2–4.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
87
Kapitel 1 Divide-and-Conquer
Selektionsproblem
Korrektheit: Klar.
Laufzeit: Wir müssen zeigen, dass die Teilprobleme in den Schritten 4, 7
bzw. 8 um einen genügend großen Faktor kleiner sind als das
Ausgangsproblem.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
88
Kapitel 1 Divide-and-Conquer
Selektionsproblem
Wieviele Elemente sind garantiert maximal so groß wie x?
x
Abbildung : Mediane der Gruppen blau gefärbt. Mediane (mit deren Gruppen)
aufsteigend sortiert. Pfeilspitzen deuten auf das jeweils größere Element. Rot: Alle
Elemente, die maximal so groß wie x sind.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
89
Kapitel 1 Divide-and-Conquer
Selektionsproblem
Effekt: bm/2c + 1 der Mediane sind maximal so groß wie x. Die Gruppen
dieser Mediane beinhalten zusätzlich noch jeweils 2 kleinere Elemente.
p ≥ 3 (bm/2c + 1) ≥ 3n/10.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
90
Kapitel 1 Divide-and-Conquer
Selektionsproblem
Wieviele Elemente sind mindestens so groß wie x?
x
Abbildung : Mediane der Gruppen blau gefärbt. Mediane (mit deren Gruppen)
aufsteigend sortiert. Pfeilspitzen deuten auf das jeweils größere Element. Rot: Alle
Elemente, die mindestens so groß wie x sind.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
91
Kapitel 1 Divide-and-Conquer
Selektionsproblem
Effekt: dm/2e der Mediane sind mindestens so groß wie x. Die Gruppen
dieser Mediane beinhalten zusätzlich noch jeweils 2 größere Elemente.
(Sonderfall: In 4-er Gruppen gibt es jeweils nur ein größeres Element.
Davon gibt es aber nur maximal 4!)
Es gilt p ≤ n − (3 · (dm/2e) − 4) ≤ 7n/10 + 4.
Also betrachten wir im rekursiven Aufruf maximal 7n/10 + 4 Elemente!
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
92
Kapitel 1 Divide-and-Conquer
Selektionsproblem
Weitere Laufzeitbetrachtungen:
Mediansuche in Schritt 3: 8 Vergleiche mit Mergesort, 6 Vergleiche
möglich (siehe Übung.)
Rekursive Mediansuche in Schritt 4: Rekursiver Aufruf mit Liste von
m = dn/5e Elementen.
Aufspalten in Schritt 5: Kosten n − 1 Vergleiche.
Kosten für Schritt 3 und 5: 6dn/5e + n − 1 <
FG KTuEA, TU Ilmenau
11
5 n
Effiziente Algorithmen – Sommersemester 2012
+6·
4
5
−1<
11
5 n
+4
93
Kapitel 1 Divide-and-Conquer
Selektionsproblem
Laufzeitanalyse: Die Laufzeit ist proportional zur Anzahl der
durchgeführten Vergleiche.
Wir definieren:
C (n) := maximale Anzahl der Vergleiche bei Aufruf
BFPRT(a1 , . . . , ap , k), p ≤ n, 1 ≤ k ≤ p.
(Durch das p ≤ n“ wird die Funktion C (n) monoton.)
”
Die Anzahl C (n) der Vergleiche im Algorithmus gehorcht der folgenden
Rekurrenzungleichung
C (n) ≤ n log n, für n ≤ n0 ;
C (n) ≤ C (dn/5e) + C (7n/10 + 4) + 11n/5 + 4, für n > n0 .
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
94
Kapitel 1 Divide-and-Conquer
Selektionsproblem
Wir behaupten: C (n) ≤ cn für alle n und eine passende Konstante c.
Die n ≤ n0 werden erledigt, indem man c ≥ log n0 wählt.
Konkret: n0 = 500; jedes c ≥ 9 erfüllt die Behauptung in diesem Fall.
Nun sei n > n0 . Wir rechnen:
C (n)
≤
C (dn/5e) + C (7n/10 + 4) + 11n/5 + 4,
I.V.
≤
cdn/5e + c(7n/10 + 4) + 11n/5 + 4
≤
cn/5 + c + 7cn/10 + 4c + 11n/5 + 4
≤
cn + (−cn/10 + 5c + 11n/5 + 4).
Entscheidend: C (n) ≤
FG KTuEA, TU Ilmenau
9
10 cn
+ O(n).
Effiziente Algorithmen – Sommersemester 2012
95
Kapitel 1 Divide-and-Conquer
Selektionsproblem
Wir wählen c so, dass cn/10 ≥ 5c + 11n/5 + 4 ist, was für c ≥ 25 und
n ≥ n0 = 500 der Fall ist (nachrechnen!).
Für ein solches c lässt sich der Induktionsschritt durchführen; damit gilt
die Behauptung C (n) ≤ cn für alle n.
Wir haben gezeigt:
Satz 1.6.2
Der BFPRT-Algorithmus löst das Auswahlproblem und hat eine Laufzeit
von O(n) im schlechtesten Fall.
Bemerkung: Durch eine viel genauere Analyse kann die Konstante in der
Vergleichsanzahl noch verbessert werden. Der beste bekannte deterministische
Algorithmus (anderer Ansatz!) benötigt (2,95 + o(1))n Vergleiche. Es ist bekannt,
dass jeder deterministische Algorithmus ≥ 2n Vergleiche benötigt.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
96
Kapitel 1 Divide-and-Conquer
FFT
1.7 Die schnelle Fourier-Transformation (FFT)
Polynom in Koeffizientendarstellung:
2
A(x) = a0 + a1 x + a2 x + . . . + an−1 x
n−1
X
=
ai x i ,
0≤i≤n−1
mit a0 , . . . , an−1 ∈ Zahlenbereich“ Z oder R oder C.
”
Für die Durchführung benötigen wir komplexe Zahlen.
Am Schluss wird eine Alternative skizziert, die man für Berechnungen über Z
benutzen kann, ohne dabei zu komplexen Zahlen überzugehen.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
97
Kapitel 1 Divide-and-Conquer
FFT
Aufgabe: Gegeben zwei Polynome A(x) und B(x), als
X
X
i
A(x) =
ai x und B(x) =
bj x j ,
0≤i≤n−1
0≤j≤n−1
berechne das Polynomprodukt
X
A(x) · B(x) = C (x) =
ck x k ,
0≤k≤2n−2
d. h. berechne die Koeffizienten ck =
P
i,j : i+j=k
ai bj .
Die Folge (c0 , . . . , c2n−2 ) heißt auch Konvolution
(a0 , . . . , an−1 ) ◦ (b0 , . . . , bn−1 ).
Naive Benutzung der Formel liefert Θ(n2 )-Algorithmus.
Ziel: O(n log n). – Methode: Divide-and-Conquer.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
98
Kapitel 1 Divide-and-Conquer
FFT
Zentraler Trick: Benutze eine weitere Darstellung von Polynomen, die
Stützstellen-Darstellung.
Betrachte eine Folge (x0 , . . . , xn−1 ) ∈ Cn von verschiedenen Stützstellen.
Fakt 1.7.1 ( Interpolation“ von Polynomen über Körpern)
”
n gibt es genau ein
Zu jedem beliebigen
Wertevektor
(r
,
.
.
.
,
r
)
∈
C
0
n−1
P
Polynom A(x) = 0≤i≤n−1 ai x i , also genau einen Koeffizientenvektor
(a0 , . . . , an−1 ), mit A(xk ) = rk für 0 ≤ k ≤ n − 1.
Es ist also egal, ob man für die Darstellung eines Polynoms seine
Koeffizienten oder einen Wertevektor benutzt.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
99
Kapitel 1 Divide-and-Conquer
FFT
Beweis von Fakt 1.7.1: Betrachte die Vandermonde-Matrix“
”

n−1 
2
1 x0
x0
· · · x0
n−1 
2
 1 x1
x
·
·
·
x
1
1


V (x0 , . . . , xn−1 ) =  .
..
..
..  .
.
 .
.
.
. 
n−1
2
1 xn−1 xn−1
· · · xn−1
Offensichtlich ist





A(x0 )
A(x1 )
..
.






=
V
(x
,
.
.
.
,
x
)
·


0
n−1


A(xn−1 )
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
a0
a1
..
.



.

an−1
100
Kapitel 1 Divide-and-Conquer
FFT
Die
Q Matrix V (x0 , . . . , xn−1 ) hat Determinante
0≤k<`≤n−1 (x` − xk ) 6= 0, ist also regulär. Daher hat das
Gleichungssystem


 
r0
a0
 a1   r1 


 
V (x0 , . . . , xn−1 ) ·  .  =  . 
 ..   .. 
rn−1
an−1
genau eine Lösung

a0
 a1

 ..
 .






 = V (x0 , . . . , xn−1 )−1 · 


an−1
FG KTuEA, TU Ilmenau
r0
r1
..
.



.

rn−1
Effiziente Algorithmen – Sommersemester 2012
101
Kapitel 1 Divide-and-Conquer
FFT
Aus der Darstellung der n-fachen Polynomauswertung als
Matrix-Vektor-Produkt folgt auch:
Bemerkung: Die Umrechnung von (a0 , . . . , an−1 ) in (r0 , . . . , rn−1 ) ist eine
(bijektive) lineare Abbildung von Cn nach Cn .
Um durch Interpolation die 2n − 1 Koeffizienten des Produktpolynoms
C (x) zu erhalten, müssen wir mit mindestens 2n − 1
Stützstellen-Werte-Paaren arbeiten. Aus technischen Gründen verwenden
wir 2n viele.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
102
Kapitel 1 Divide-and-Conquer
FFT
Algorithmenplan für die Polynommultiplikation:
Eingabe: Zwei Polynome A(x) und B(x) als
Koeffizientenvektoren (a0 , . . . , an−1 ) und (b0 , . . . , bn−1 ).
x0 , x1 , . . . , x2n−1 seien verschiedene Stützstellen.
(1) Polynomauswertung:
Berechne A(xk ) und B(xk ), für k = 0, . . . , 2n − 1.
(2) Berechne durch punktweise Multiplikation Werte des
Produktpolynoms C (x):
C (xk ) := A(xk ) · B(xk ), für k = 0, . . . , 2n − 1.
(3) Interpolation:
Berechne aus (C (x0 ), C (x1 ), . . . , C (x2n−1 )) die Koeffizienten
(c0 , . . . , c2n−1 ) von C (x).
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
103
Kapitel 1 Divide-and-Conquer
FFT
Kosten:
(a0 , . . . , an−1 , b0 , . . . , bn−1 )
(c0 , . . . , c2n−1 )
(1) Auswertung
A(xk ), B(xk ), 0 ≤ k ≤ 2n − 1
(3) Interpolation
(2) A(xk ) · B(xk )
C (xk ), 0 ≤ k ≤ 2n − 1
(1) ?? Naiv: Jeden Wert A(xk ) separat berechnen, z. B. mit dem
Horner-Schema:
A(xk ) = ((. . . (an−1 · xk + an−2 ) · xk . . .) · xk + a1 ) · xk + a0
Kosten: O(n2 ).
(2) O(n).
(3) ?? (Auch hier: O(n2 ) recht leicht zu erreichen.)
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
104
Kapitel 1 Divide-and-Conquer
FFT
Kosten:
(a0 , . . . , an−1 , b0 , . . . , bn−1 )
(c0 , . . . , c2n−1 )
(1) O(n2 )
A(xk ), B(xk ), 0 ≤ k ≤ 2n − 1
(3) O(n2 )
(2) O(n)
C (xk ), 0 ≤ k ≤ 2n − 1
Unser Ziel: O(n log n) für (1) und (3).
Zunächst: Auswertung, für n = 2L Stützstellen.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
104
Kapitel 1 Divide-and-Conquer
FFT
Wollen dafür nutzen: Divide-and-Conquer!
Idee: Nutze geschickt gewählte Stützstellen x0 , . . . , xn−1 .
Dafür: Wähle x0 , . . . , xn/2−1 verschieden und betrachte als Stützstellen
±x0 , ±x1 , . . . , ±xn/2−1 .
Bei der Auswertung von A(xi ) und A(−xi ) wird viel Arbeit doppelt
verrichtet, nämlich die Auswertung bei den geraden Potenzen von x in
A(x).
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
105
Kapitel 1 Divide-and-Conquer
FFT
Ansatz: Divide-and-Conquer.
Wenn n = 1, ist das Ergebnis (r0 ) = (a0 ).
Wenn n > 1, teilen wir A(x) in zwei Teilpolynome auf:
A(x) = (a0 + a2 x 2 + a4 x 4 + · · · + an−2 x n−2 )
+ x(a1 + a3 x 2 + a5 x 4 + · · · + an−1 x n−2 ),
mit den Abkürzungen ( gerade“, “ungerade“)
”
Ag (x) := a0 + a2 x + · · · + an−2 x n/2−1 und
Au (x) := a1 + a3 x + · · · + an−1 x n/2−1 also
A(x) = Ag (x 2 ) + xAu (x 2 ).
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
(2)
106
Kapitel 1 Divide-and-Conquer
FFT
A(x) = Ag (x 2 ) + xAu (x 2 ).
Dann gilt für Plus-Minus“-Paare von Stützstellen:
”
A(xi ) = Ag (xi2 ) + xi Au (xi2 )
A(−xi ) = Ag (xi2 ) − xi Au (xi2 )
Also: 2 Teilprobleme der Größe n/2, O(1) Aufwand zum Kombinieren.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
107
Kapitel 1 Divide-and-Conquer
FFT
Problem: Auf oberster Rekursionsstufe: ±x0 , . . . , ±xn/2−1 als
Plus-Minus“-Paare gewählt.
”
2
Im rekursiven Aufruf: x02 , . . . , xn/2−1
müssen wieder die Eigenschaft
besitzen, dass wir Plus-Minus“-Paare dort finden!
”
Wie soll das gehen?
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
108
Kapitel 1 Divide-and-Conquer
FFT
ω sei primitive n-te Einheitswurzel, d. h.
(i) ω n = 1,
(ii) für 1 ≤ k ≤ n − 1 gilt
P
(ω k )j = 0.
0≤j≤n−1
(iii) ω k 6= 1, für 1 ≤ k ≤ n − 1.
Unter einfachen weiteren Voraussetzungen
sind (ii) und (iii) äquivalent:
P
– Wenn ω k = 1 ist, dann folgt 0≤j≤n−1 (ω k )j = n.
Daher folgt (iii), wenn (ii) und n 6= 0 gelten.
k
– Wenn ωP
6= 1 gilt, schreiben wir:
(ω k − 1)( 0≤j≤n−1 (ω k )j ) = (ω k )n − 1 = 0.
Daher folgt (ii), wenn (iii) gilt und zudem
die Inversen (ω k − 1)−1 existieren.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
109
Kapitel 1 Divide-and-Conquer
FFT
In C: Eine primitive n-te Einheitswurzel ist
ω := e 2πi/n = cos(2π/n) + i sin(2π/n),
wobei hier i die imaginäre Einheit ist. (Beweis dieser Eigenschaft: später.)
In der komplexen Zahlenebene liegt der Punkt ω also auf dem
Einheitskreis, von 1 aus um den Winkel 2π/n gegen den Uhrzeigersinn
verdreht.
Die Potenzen ω k , 0 ≤ k ≤ n − 1, liegen in gleichen Abständen auf dem
Einheitskreis.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
110
Kapitel 1 Divide-and-Conquer
FFT
i
4π
n
ω2
2π
n
ω
0
−1
2π
n
1
+π
−i
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
111
Kapitel 1 Divide-and-Conquer
FFT
Für n = 2L gilt:
ω 0 = 1, ω n/2 = −1.
Also j ∈ {0, . . . , n/2 − 1} : ω j = −ω n/2+j . Wir finden also ±-Paare.
ω 2 ist selbst eine primitive Einheitswurzel für n/2. Im
Rekursionsschritt werden wir wieder ±-Paare finden.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
112
Kapitel 1 Divide-and-Conquer
FFT
Rekursion: 8 Stützstellen.
16 Stützstellen.
i
i
4π
n
4π
n
ω2
2π
n
ω
0
−1
2π
n
1
0
−1
1
+π
4π
n
+π
−i
FG KTuEA, TU Ilmenau
−i
Effiziente Algorithmen – Sommersemester 2012
113
Kapitel 1 Divide-and-Conquer
FFT
Als (x0 , x1 , . . . , xn−1 ) wählen wir (ω 0 , ω 1 , . . . , ω n−1 ).
(Beachte: ω 0 = 1, ω 1 = ω.)
P
Gegeben A(x) = 0≤i≤n−1 ai x i als Koeffizientenvektor (a0 , a1 , . . . , an−1 ),
wollen wir also die
diskrete Fourier-Transformierte
(r0 , r1 , . . . , rn−1 ) = (A(1), A(ω), A(ω 2 ), . . . , A(ω n−1 ))
von (a0 , . . . , an−1 ) berechnen.
Die Operation (a0 , . . . , an−1 ) 7→ (A(1), A(ω), A(ω 2 ), . . . , A(ω n−1 )) heißt
die diskrete Fourier-Transformation.
Es handelt sich dabei um eine lineare Bijektion von Cn nach Cn .
(Es gibt auch eine Fourier-Transformation für Funktionen, die auf
Integralen beruht.)
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
114
Kapitel 1 Divide-and-Conquer
FFT
Der Ablauf ist wie folgt:
A(x) = Ag (x 2 ) + xAu (x 2 ).
Wir berechnen zunächst rekursiv die n Werte
(s0 , . . . , sn/2−1 ) = (Ag ((ω 2 )0 ), Ag ((ω 2 )1 ), . . . , Ag ((ω 2 )n/2−1 ))
und
(t0 , . . . , tn/2−1 ) = (Au ((ω 2 )0 ), Au ((ω 2 )1 ), . . . , Au ((ω 2 )n/2−1 )).
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
115
Kapitel 1 Divide-and-Conquer
FFT
Erinnerung: Für ±-Paare gilt:
A(xi ) = Ag (xi2 ) + xi Au (xi2 )
A(−xi ) = Ag (xi2 ) − xi Au (xi2 )
Also wird (r0 , r1 , . . . , rn−1 ) wie folgt berechnet:
Für j = 0, . . . , n/2 − 1:
rj = A(ω j ) = Ag ((ω j )2 ) + ω j · Au ((ω j )2 ) = sj + ω j · tj .
rn/2+j = A(−ω j ) = Ag ((ω 2 )j ) − ω j · Au ((ω 2 )j ) = sj − ω j · tj .
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
116
Kapitel 1 Divide-and-Conquer
FFT
Algorithmus FFT (Schnelle Fourier-Transformation)
Eingabe: (Koeffizienten-)Vektor (a0 , . . . , an−1 ),
für Zweierpotenz n; primitive n-te Einheitswurzel ω.
if n = 1 then return (a0 );
(s0 , . . . , sn/2−1 ) := FFT((a0 , a2 , . . . , an−2 ), ω 2 );
(t0 , . . . , tn/2−1 ) := FFT((a1 , a3 , . . . , an−1 ), ω 2 );
for j from 0 to n/2 − 1 do
rj := sj + ω j · tj ;
rn/2+j := sj − ω j · tj ;
return (r0 , r1 , . . . , rn−1 ).
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
117
Kapitel 1 Divide-and-Conquer
FFT
Korrektheit: Folgt aus den vorangegangenen Überlegungen.
Laufzeit: Entscheidend ist die Anzahl C (n) der arithmetischen
Operationen bei Eingaben der Länge n.
Rekurrenz:
C (n) ≤
1
2 · C (n/2) + cn
, falls n = 1
, sonst,
für eine Konstante c. Mit dem Master-Theorem, 2. Fall, ergibt sich
C (n) = O(n log n).
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
118
Kapitel 1 Divide-and-Conquer
FFT
Satz 1.7.2
Algorithmus FFT berechnet die diskrete Fouriertransformierte eines
Koeffizientenvektors im Bezug auf die Stützstellen (1, ω, ω 2 , . . . , ω n−1 ),
wobei ω eine primitive n-te Einheitswurzel ist, in Zeit O(n log n).
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
119
Kapitel 1 Divide-and-Conquer
FFT
Kurzer Einschub: Beweis dafür, dass ω eine n-te Einheitswurzel ist.
Wissen schon, dass (i) gilt.
(ii) Für jedes beliebige y gilt
X
j
2
4
2L−1
y = (1 + y )(1 + y )(1 + y ) · · · (1 + y
).
(3)
0≤j≤n−1
(Ausmultiplizieren des Produkts ergibt n = 2L Summanden y j , bei denen
jeder Exponent j ∈ {0, . . . , 2L − 1} genau einmal vorkommt, wegen der
Eindeutigkeit der Binärdarstellung.)
Wir betrachten (3) für y = ω k , für 1 ≤ k ≤ n − 1.
Schreibe k = u · 2` , mit u ungerade und 0 ≤ ` < L. Dann ist
k 2L−`−1
(ω )
=ω
u(2L−1 )
= (ω n/2 )u = (−1)u = −1,
L−`−1
k )2
weil u ungerade ist. Also
ist
der
Faktor
(1
+
(ω
P
in (3) gleich 0, also ist 0≤j≤n−1 (ω k )j = 0.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
)
120
Kapitel 1 Divide-and-Conquer
FFT
Aktueller Stand:
(a0 , . . . , an−1 , b0 , . . . , bn−1 )
(c0 , . . . , c2n−1 )
(3) O(n2 )
(1) O(n log n)
A(xk ), B(xk ), 0 ≤ k ≤ 2n − 1
(2) O(n)
C (xk ), 0 ≤ k ≤ 2n − 1
Es fehlt noch: Interpolation.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
121
Kapitel 1 Divide-and-Conquer
FFT
Auch hier ein schöner Trick.
Gegeben ist (r0 , . . . , rn−1 ), gesucht der Koeffizientenvektor (a0 , . . . , an−1 ),
der M(ω) · (a0 , . . . , an−1 )T = (r0 , . . . , rn−1 )T erfüllt, für die Matrix M(ω)
der diskreten Fourier-Transformation:
M(ω) = ((ω i )j )0≤i,j≤n−1

1
1
1
2
 1
ω
ω

2 )2
 1 ω2
(ω
= 
 ..
..
..
 .
.
.
1 ω n−1 (ω n−1 )2
FG KTuEA, TU Ilmenau
···
···
···
1
ω n−1
(ω 2 )n−1
..
.
· · · (ω n−1 )n−1
Effiziente Algorithmen – Sommersemester 2012




 .


122
Kapitel 1 Divide-and-Conquer
FFT
Man kann die zu M(ω) inverse Matrix direkt bestimmen.
Setze ω̂ := ω n−1 .
Dann gilt ω · ω̂ = ω n = 1, also ist ω̂ = ω −1 .
Betrachte
M(ω̂) = ((ω̂ i )j )0≤i,j≤n−1

1
1
1
2
 1
ω̂
ω̂

2

(ω̂ 2 )2
=  1 ω̂
 ..
..
..
 .
.
.
1 ω̂ n−1 (ω̂ n−1 )2
FG KTuEA, TU Ilmenau
···
···
···
1

ω̂ n−1
(ω̂ 2 )n−1
..
.






· · · (ω̂ n−1 )n−1
Effiziente Algorithmen – Sommersemester 2012
123
Kapitel 1 Divide-and-Conquer
FFT
Wir berechnen den Eintrag zij an Stelle (i, j) der Produktmatrix
M(ω) · M(ω̂):
X
X
i k
k j
zij =
(ω ) · (ω̂ ) =
(ω i+(n−1)j )k .
0≤k≤n−1
0≤k≤n−1
Es gibt zwei Fälle. Wenn i = j gilt, ist ω i+(n−1)j = (ω n )i = 1, und die
Summe ist n.
Wenn i > j gilt, ist ω i+(n−1)j = ω ` für 1 ≤ ` = i − j ≤ n − 1.
Wenn i < j gilt, ist ω i+(n−1)j = ω ` für 1 ≤ ` = n − (j − i) ≤ n − 1.
Wegen Bedingung (ii):
X
(ω ` )k = 0.
zij =
0≤k≤n−1
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
124
Kapitel 1 Divide-and-Conquer
FFT
Also: M(ω) · M(ω̂) = n · In , für die n × n-Einheitsmatrix In .
Das heißt: M(ω)−1 = n−1 · M(ω̂).
Wenn also (r0 , . . . , rn−1 ) der für die Interpolation gegebene Wertevektor
ist, so erhalten wir den Koeffizientenvektor als
(a0 , . . . , an−1 )T = n−1 · M(ω̂) · (r0 , . . . , rn−1 )T .
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
125
Kapitel 1 Divide-and-Conquer
FFT
Für die Zahl ω̂ beobachten wir:
(i) ω̂ n = (ω n−1 )n = (ω n )n−1 = 1n−1 = 1,
(ii) für 1 ≤ k ≤ n − 1 gilt ω̂ kP= (ω n−1 )k = ω n(k−1) ω n−k = ω n−k , mit
1 ≤ n − k ≤ n − 1, also 0≤j≤n−1 (ω̂ k )j = 0.
Das heißt: Auch ω̂ ist eine primitive n-te Einheitswurzel.
Multiplikation mit M(ω̂) entspricht der FFT-Operation mit ω̂ an Stelle von
ω. – Wir erhalten für die Interpolation:
(a0 , . . . , an−1 ) = n−1 · FFT((r0 , . . . , rn−1 ), ω̂).
Zeitaufwand: O(n log n).
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
126
Kapitel 1 Divide-and-Conquer
FFT
Wir können nun unseren Algorithmenplan umsetzen:
Algorithmus FFT-PM (Polynommultiplikation)
Eingabe: (Koeffizienten-)Vektoren (a0 , . . . , an−1 ), (b0 , . . . , bn−1 ),
für Zweierpotenz n.
Berechne 2n-te Einheitswurzeln ω := e πi/n und ω̂ := ω 2n−1 .
A
(r0A , . . . , r2n−1
) := FFT((a0 , . . . , an−1 , 0, . . . , 0), ω);
B
(r0B , . . . , r2n−1
) := FFT((b0 , . . . , bn−1 , 0, . . . , 0), ω);
for j from 0 to 2n − 1 do rjC := rjA · rjB ;
(c0 , c1 , . . . , c2n−1 ) :=
1
2n
C
· FFT((r0C , . . . , r2n−1
), ω̂);
return (c0 , c1 , . . . , c2n−1 ).
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
127
Kapitel 1 Divide-and-Conquer
FFT
Satz 1.7.3
Algorithmus FFT-PM berechnet die Koeffizienten des Produktes zweier
durch Koeffizientenvektoren gegebener Polynome in Zeit O(n log n).
Beweis: Siehe vorherige Überlegungen.
(Rechenaufwand: O(2n log(2n)) = O(n log n).)
(a0 , . . . , an−1 , b0 , . . . , bn−1 )
(c0 , . . . , c2n−1 )
(1) O(n log n)
A(xk ), B(xk ), 0 ≤ k ≤ 2n − 1
FG KTuEA, TU Ilmenau
(3) O(n log n)
(2) O(n)
C (xk ), 0 ≤ k ≤ 2n − 1
Effiziente Algorithmen – Sommersemester 2012
128
Kapitel 1 Divide-and-Conquer
FFT
Für Zuhause: Es folgen weitere Anmerkungen zur Geschichte und
Anwendung der FFT. (Nicht prüfungsrelevant.)
Zum Üben: Berechnen Sie (x + 1) · (x 2 + 1) mittels FFT!
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
129
Kapitel 1 Divide-and-Conquer
FFT
Der FFT-Ansatz ermöglicht es auch, die diskrete Fourier-Transformatierte
eines Vektors sehr effizient parallel zu berechnen, entweder mit mehreren
Prozessoren oder sogar in Hardware.
Die Überlegungen hierzu führen auch zu einer sehr effizienten iterativen
Formulierung des Algorithmus.
In Algorithmus FFT können die beiden rekursiven Aufrufe unabhängig
voneinander parallel durchgeführt werden (in Hardware: zwei Kopien der
gleichen Schaltung nötig). Die Berechnung des Resultates (r0 , . . . , rn−1 )
kann sogar für alle n Werte gleichzeitig erfolgen.
Eine Beispielschaltung findet man auf Seite 69 im Buch von S. Dasgupta,
C. Papadimitriou, U. Vazirani, Algorithms, McGraw-Hill, 2007.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
130
Kapitel 1 Divide-and-Conquer
FFT
Wozu eigentlich Polynommultiplikation oder Faltung“
”
X
ck =
ai bj , für 0 ≤ k ≤ 2n − 1 ?
i,j : i+j=k
Zentrales Hilfsmittel bei der Digitalen Signalverarbeitung“.
”
Offizielle Publikation: [Cooley/Tukey 1965].
Form des Algorithmus 1805 von C. F. Gauß entworfen (und zur
Berechnung von Asteroidenbahnen benutzt).
Erstmalig publiziert wurde eine Variante des Algorithmus von C. Runge
(1903/05).
(Quelle hierfür: Wikipedia – kann stimmen, muss aber nicht.)
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
131
Kapitel 1 Divide-and-Conquer
FFT
Wir stellen uns ein System vor, in dem regelmäßig Signale anfallen und (zu
Ausgabesignalen) verarbeitet werden.
Abtastzeitpunkte t0 , t1 , . . . mit festem Abstand ∆ = ti+1 − ti liefern
(reelle, komplexe) Signalwerte a0 , a1 , a2 , . . ..
Ein Verarbeitungsmechanismus soll diese Messwertfolge in eine
Ausgabefolge c0 , c1 , c2 , . . . umsetzen, mit Ausgabezeiten t00 , t10 , t20 , . . .,
ebenso mit Abstand ∆.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
132
Kapitel 1 Divide-and-Conquer
FFT
Die einfachsten Mechanismen sind linear . . .
(wenn man zwei Signalfolgen addiert, addieren sich die Ausgabefolgen,
ebenso bei Multiplikation mit konstanten Faktoren)
und zeitinvariant . . .
(wenn die gleiche Signalfolge um einen Zeitschritt ∆ versetzt auftritt,
ergibt sich die gleiche um ∆ versetzte Ausgabefolge).
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
133
Kapitel 1 Divide-and-Conquer
FFT
Leicht zu sehen: Bei linearen, zeitinvarianten Signalverarbeitungs-Systemen
ist durch die Ausgabefolge (b0 , b1 , b2 , . . .), die von einem Signal der Größe
1 bei t0 und sonst nur Nullsignalen ausgelöst wird, die Ausgabefolge
(c0 , c1 , c2 , . . .) auf einer beliebigen Signalfolge (a0 , a1 , . . .) eindeutig
bestimmt, durch:
X
ck =
ai bj .
i+j=k
Das ist gerade die Folge der Koeffizienten des Produktpolynoms.
D.h.: Lineare, zeitinvariante Reaktion auf Mess-Signale führt unmittelbar
zum Problem Polynommultiplikation“.
”
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
134
Kapitel 1 Divide-and-Conquer
FFT
Multiplikation ganzer Zahlen“:
”
Wir wollen zwei Zahlen x, y mit je N Bits multiplizieren, N ist extrem
groß.
√
Wir zerlegen die Binärdarstellung von x und y in Blöcke der Länge N.
Indem wir jeweils jeden dritten Block nehmen, bilden wir aus x und y
jeweils drei Zahlen, so dass
x = x0 + x1 + x2 und y = y0 + y1 + y2
√
gilt und so
√ dass xi · yj als Multiplikation von Zahlen mit N Ziffern im
Bereich [ N] aufgefasst werden kann. Durch die großen eingestreuten
Blöcke von Nullen gibt es keine Überträge.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
135
Kapitel 1 Divide-and-Conquer
FFT
Die Ziffern“ der Produkte xi · yj stellen sich als die Koeffizienten eines
”
Produktpolynoms heraus.
√
Mit der FFT könnte man diese Ziffern der Teilprodukte in O( N log N)
Multiplikationen von komplexen Zahlen ermitteln.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
136
Kapitel 1 Divide-and-Conquer
FFT
Unter der Annahme, dass eine solche Multiplikation (durch
√ geeignete
Rundung auf komplexe Zahlen mit Darstellungslänge O( N)) in Zeit
O(N) möglich ist, erhalten wir einen Gesamtzeitaufwand von
O(N 3/2 log N), sogar besser als der Zeitbedarf des
Karatsuba-Multiplizierers.
Durch Einziehen von Rekursionsstufen lässt sich die Zeit weiter drücken;
wenn man es konsequent durchführt, auf O(N 1+ε ) für beliebige konstante
ε > 0 (Verfahren von Toom/Cook, z. B. im Buch The Art of Computer
”
Programming, Vol. 2: Seminumerical Algorithms“ von D. Knuth
beschrieben).
Für den Multiplikationsalgorithmus von Schönhage und Strassen mit
Kosten O(N log N log log N) sind neben der FFT noch weitere Ideen nötig.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
137
Kapitel 1 Divide-and-Conquer
FFT
Bemerkung für C-Vektorraum-Spezialisten:
Die DFT ist eine Koordinatentransformation für einen Basiswechsel im
C-Vektorraum Pn der Polynome vom Grad bis zu n − 1.
Man betrachtet ein inneres Produkt in Pn :
DX
E
X
ai X i ,
bi X i =
i
i
X
ai b i .
0≤i≤n−1
Definiere fj (X ) als das (eindeutig bestimmte) Polynom, das
fj (ω k ) = [j = k] erfüllt, für 0 ≤ k ≤ n − 1. Dann ist die Standardbasis“
”
2
Bn = (1, X , X , . . . , Xn−1 ) Orthonormalbasis von Pn
und die Fourierbasis“ Fn = (f0 (X ), f1 (X ), . . . , fn−1 (X )) Orthogonalbasis
”
von Pn .
Die Matrix M(ω) ist die Matrix für den Basiswechsel von Bn (Koeffizienten
(a0 , . . . , an−1 ) nach Fn (Koeffizienten (A(ω 0 ), . . . , A(ω n−1 ))), die Matrix
M(ω)−1 = n1 M(ω̂) ist für den umgekehrten Basiswechsel zuständig.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
138
Kapitel 1 Divide-and-Conquer
FFT
Für die Arbeit mit ganzen Zahlen ist die oben beschriebene FFT sehr
unbequem, weil man mit komplexen Zahlen rechnen muss.
In gewissen Situationen kann man FFT auch modulo m“ durchführen, für
”
geeignete Teiler m, und ganz im diskreten Bereich bleiben.
Fakt 1.7.4
Wenn w = 2 und n eine Zweierpotenz ist, dann gilt für m = 2n/2 + 1:
(i) w n mod m = 1 und w n/2 mod m = −1.
P
(ii) Für 1 ≤ k ≤ n − 1 gilt 0≤j≤n−1 (w k )j = 0.
(iii) Für 1 ≤ k ≤ n − 1 gilt w k 6= 1.
(iv) Es gibt n̂, ŵ mit (n · n̂) mod m = 1 und (w · ŵ ) mod m = 1.
Die Zahl w spielt also im Ring Zm die Rolle einer n-ten Einheitswurzel, sie
besitzt eine Inverse ŵ , und auch n hat eine Inverse n̂.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
139
Kapitel 1 Divide-and-Conquer
FFT
Beispiel: w = 2, n = 32, m = 216 + 1 = 65537, ŵ = 32769, n̂ = 63489.
Man kann sich überlegen, dass in dieser Situation alle Überlegungen, die
wir oben für ω, ω̂, n, n−1 angestellt haben, für w , ŵ , n, n̂ ebenso
funktionieren, wir also den FFT-Algorithmus auch mit Addition und
Multiplikation modulo m“ benutzen können, obwohl Zm normalerweise
”
kein Körper ist. Damit lassen sich die Koeffizienten von Produkten
ganzzahliger Polynome mit FFT ohne Umweg über die komplexen Zahlen
berechnen, und auch in der Situation der Multiplikation von ganzen Zahlen
ist diese FFT-Version günstiger. Einzige Voraussetzung: m muss so groß
sein, dass die Koeffizienten ck des Produktpolynoms schon durch den Wert
ck mod m eindeutig bestimmt sind.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – Sommersemester 2012
140