Effiziente Algorithmen

Hörer:
SS09
Effiziente Algorithmen
Vorbemerkungen und 1. Kapitel
Informatikstudierende (Bachelor) im 4. Semester,
Mathematikstudierende, andere Fächer bei Bedarf
Material: Eigene Mitschrift
Folienkopien, Übungsblätter
Martin Dietzfelbinger
auf der folgenden Webseite:
April 2009
http://www.tu-ilmenau.de/fakia/Effiziente-Algorithm.ea_ss080.0.html
Zugang über die Institutsseite.
Stoff: Vorlesung + Übungsaufgaben.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS09 – Kapitel 0+1
FG KTuEA, TU Ilmenau
Zur Arbeitsweise:
Der Stoff ist zu kompliziert und zu umfangreich, um
durch reines Zuhören verstanden zu werden.
• Regelmäßig Vorlesung nacharbeiten.
Semesterbegleitend!
Effiziente Algorithmen – SS09 – Kapitel 0+1
1
Zeitaufwand?
Leistungspunkte: 4 LP – Entspricht 120 Zeitstunden.
Vorlesungszeit: 15 Wochen.
6 Stunden pro Woche
Davon: 2 12 – 3 in Vorlesung/Übung
• Bücher konsultieren.
• Übungsblätter drucken, lesen, zur Übung mitbringen,
vorher Lösung ausdenken, Lösungsweg aufschreiben, an
Lösungen mitarbeiten.
Zeitaufwand: 3 – 3 12 Zeitstunden pro Woche
neben Vorlesung + Übung.
plus 30 Stunden Prüfungsvorbereitung!
• Regelmäßig Übungen nacharbeiten. Semesterbegleitend!
• Bei Verständnisproblemen frühzeitig fragen!
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS09 – Kapitel 0+1
2
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS09 – Kapitel 0+1
3
Literatur:
• 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
• K. Mehlhorn, P. Sanders, Algorithms and Data Structures:
The Basic Toolbox, Springer-Verlag, 2008
• 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.
• J. Kleinberg, E. Tardos, Algorithm Design, Pearson Education, 2005
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS09 – Kapitel 0+1
4
Übungsleiterin:
Frau Lucia Draque Penso, Ph.D.(Brown U.)
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS09 – Kapitel 0+1
5
Themen:
1. Divide-and-Conquer
• Multiplikation ganzer Zahlen: Algorithmus von KaratsubaOfman
• Dienstag (G), 11:00-12:30, HU011
• Donnerstag (G), 09:00-10:30, HU011
• Matrixmultiplikation: Algorithmus von Schönhage-Strassen
• Freitag (U), 09:00-10:30, HU202
• Erinnerung: Mergesort, Quicksort
• Selection in Zeit O(n) – Algorithmus von BFPRT
(Blum, Floyd, Pratt, Rivest, Tarjan)
Prüfung: (Bachelor Informatik) September 2009, mündlich
(andere) nach Vereinbarung, mündlich.
• Schneller Selection-Algorithmus: Randomisiert
• Rekurrenz(un)gleichungen, insbesondere: Master-Theorem
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS09 – Kapitel 0+1
6
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS09 – Kapitel 0+1
7
2. Durchsuchen und Strukturanalyse von Graphen
3. Greedy-Strategie allgemein
• Erinnerung: Breitensuche, Tiefensuche
• Teilbares Rucksackproblem
• Erweiterte Tiefensuche mit:
• Schedulingprobleme
• Kreisfreiheitstest, Finden von Kreisen
• Kürzeste Wege 1: Algorithmus von Dijkstra
• Topologische Sortierung
• Huffman-Kodierung
• Starke Zusammenhangskomponenten
• Tiefensuche in ungerichteten Graphen mit Kreisfreiheitstest
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS09 – Kapitel 0+1
8
4. Minimale Spannbäume: Greedy-Strategie speziell,
Hilfsstrukturen
• Union-Find-Datenstruktur
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS09 – Kapitel 0+1
9
5. Dynamische Programmierung
• Editierdistanz
• Matrix-Ketten-Multiplikation
• MST: Der Rot-Blau-Satz
• MST: Algorithmus von Kruskal
• Kürzeste Wege 2: Algorithmus von Floyd-Warshall, Transitive Hülle
• Priority-Queue mittels binärer Heaps
• Kürzeste Wege 3: Algorithmus von Bellman-Ford
• MST: Algorithmus von Prim
• Optimale binäre Suchbäume
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS09 – Kapitel 0+1
10
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS09 – Kapitel 0+1
11
6. Textalgorithmen
7. Flüsse in Netzwerken
• Knuth-Morris-Pratt-Algorithmus
• Boyer-Moore-Algorithmus
• Das Problem Maximaler Fluss in Netzwerk“
”
• Algorithmus von Ford-Fulkerson
• Textkompression nach Lempel-Ziv-Welch
• Max-Flow-Min-Cut-Theorem
• Algorithmus von Edmonds-Karp: Voll polynomiell
• Maximales Matching in bipartiten Graphen
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS09 – Kapitel 0+1
12
8. Suchen in impliziten Bäumen
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS09 – Kapitel 0+1
13
Kapitel 1 Divide-and-Conquer
• Backtracking
• Branch-and-Bound
Ein Algorithmenparadigma“.
”
Divide-and-Conquer — divide et impera — teile und herrsche
• Spielbaumsuche
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, . . . , yb ( teile“).
”
Rufe A rekursiv für y1, . . . , yb auf,
was Lösungen r1, . . . , rb liefert.
Gewinne aus x, y1, . . . , yb, r1, . . . , rb eine Lösung r des Problems P für Instanz x ( kombiniere“).
”
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS09 – Kapitel 0+1
14
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS09 – Kapitel 0+1
15
Standardbeispiele für D-a-C-Algorithmen:
1.1 Multiplikation
• Mergesort
Binärdarstellung!
• Quicksort
Methoden funktionieren im Prinzip für jede beliebige Basis.
• Binäre Suche
Addition
Fortgeschrittenes Beispiel (nicht in dieser Vorlesung):
an−1 . . . a0 + bn−1 . . . b0
Algorithmus Serielle Binäraddition
• Schnelle Fouriertransformation
Input: Binärzahlen/-strings an−1 . . . a0 und bn−1 . . . b0
Volladierer (5 Bitoperationen) liefert zu 3 Bits d, e, f die zwei
Bits (s, c) = fulladd(d, e, f ) mit
s = d ⊕ e ⊕ f (Summenbit) und
c = (d ∧ e) ∨ (e ∧ f ) ∨ (f ∧ d) (Übertragsbit, Carry).
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS09 – Kapitel 0+1
16
c0 ← 0;
for i from 0 to n − 1 do
(si, ci+1) ← fulladd(ai, bi, ci);
sn ← c n ;
Ergebnis: (sn . . . s0).
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS09 – Kapitel 0+1
17
Multiplikation zweier natürlicher Zahlen
Schulmethode“
”
100110 · 110011 :
1 0 0 1
1 0 0
0 0
0
0
1
0
0
0
1
1 1 1 1 0 0
Kosten: Nicht mehr als 5n = O(n) Bitoperationen.
Negative Zahlen, Subtraktion
Im Folgenden: Ganze Zahlen als Paar (Vorzeichen, Absolutbetrag) dargestellt:
10, −1001, 101010, −11110
1
1
0
0
1
0
0
0
0
0
1
0
0
1
0
0
0
1 0
1 1 0
0 1 0
Additionen und Subtraktionen solcher Zahlen sind mit der
Zweierkomplementdarstellung auf die Addition zurückführbar, kosten nicht mehr als 10n Bitoperationen.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS09 – Kapitel 0+1
18
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS09 – Kapitel 0+1
19
Allgemein:
Multiplikation mit Divide-and-Conquer:
Input: Binärzahlen/-strings an−1 . . . a0 und bn−1 . . . b0
Bilde n Zahlen d
(0)
(n−1)
,...,d
Eingabe: n-Bit-Binärzahlen x und y, eventuell mit Vorzeichen.
Falls n ≤ n0: Benutze Schulmethode.
:
d(i) = (an−1 · bi) . . . (a0 · bi) 0 .
. . 0
Falls n > n0: Setze k = n/2.
und addiere alle diese.
Schreibe x = x
. . . x0
n−1. . . xk x
k−1
n − 1 Additionen von Zahlen mit nicht mehr als 2n Bits:
und y = y n−1. . . yk y k−1
. . . y0
i Nullen
A
O(n2) Bitoperationen.
C
B
D
Teile“!
”
Dann x = A · 2k + B und y = C · 2k + D.
Geht es billiger?
Also
x·y = (A·2k +B)(C·2k +D) = AC·22k +(AD+BC)·2k +BD.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS09 – Kapitel 0+1
20
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS09 – Kapitel 0+1
21
x·y = (A·2k +B)(C·2k +D) = AC·22k +(AD+BC)·2k +BD.
Erste Idee: Berechne rekursiv AC, AD, BC, CD,
und füge die Produkte durch einige Additionen zum Resultat
x · y zusammen.
Trick:
E := A − B und F := C − D
(sieht sinnlos aus . . . )
Man kann zeigen (machen wir später):
Bemerke: |E| und |F | haben als Differenz zweier nichtnegativer
k-Bit-Zahlen höchstens k Bits!
Die Anzahl der Bitoperationen ist wieder Θ(n2).
Nun: E · F = (A − B)(C − D) = AC + BD − (AD + BC).
Also: AD + BC = AC + BD − EF .
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS09 – Kapitel 0+1
22
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS09 – Kapitel 0+1
23
Eingesetzt: x · y = AC · 22k + (AC + BD − EF ) · 2k + BD.
Algorithmus KO (Karatsuba-Ofman)
Wir müssen (rekursiv) t = 3 Teilprobleme für die Parametergröße n/a = n/2, also a = 2, lösen:
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 := KO(A, C); (∗ Rekursion ∗)
H := KO(B, D); (∗ Rekursion ∗)
I := KO(|E|, |F |); (∗ Rekursion ∗)
return G · 22k + (G + H − sign(E) · sign(F ) · I) · 2k + H.
AC, BD, EF berechnen
und müssen einige Additionen und Subtraktionen von Zahlen
mit maximal 2n Bits durchführen:
O(n) Bitoperationen.
Algorithmus von Karatsuba-Ofman
Dabei ist sign(a) das Vorzeichen von a.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS09 – Kapitel 0+1
24
Beispiel: Mit Dezimalzahlen, n0 = 2.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS09 – Kapitel 0+1
25
g = 76 · 35 = 2660, h = 98, i = 27 · 33 = 891.
Methode funktioniert zu jeder Basis!
In der Informatik interessante Basiszahlen: 2, 8, 10, 16, 256,
216, 232, . . .
n = 8, x = 76490358, y = 35029630.
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.
A = 7649, B = 0358, C = 3502, D = 9630.
E = A − B = 7291, F = C − D = −6128.
Ergebnis:
Jeweils ≤ 4 Dezimalziffern.
x · y = 26786798 · 108 + (26786798 + 03447540 − (−1) ·
44679248) · 104 + 03447540 = 2679428939307540
Rekursion für a · C:
a = 76, b = 49, c = 35, d = 02.
e = a − b = 27, f = c − d = 33.
Nur Additionen!
Weil z.B. n0 = 2 ist, wird direkt multipliziert:
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS09 – Kapitel 0+1
26
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS09 – Kapitel 0+1
27
MKO(n0) = 1 und MKO(n) = 3MKO(n/2).
Einfachst-Analyse:
Es sei n0 = 1 und n sei eine Zweiterpotenz: n = 2.
MKO(n) = Anzahl der Bit-Multiplikationen (∧-Operationen).
TKO(n) = Anzahl der Bit-Operationen.
MKO(2) = 3 · MKO(2−1)
= 32 · MKO(2−2)
TKO(n0) = 1 und TKO(n) ≤ 3TKO(n/2) + cn, wobei c konstant ist.
= 33 · MKO(2−3)
..
MKO(n0) = 1 und MKO(n) = 3MKO(n/2).
= 3 · MKO(2−) = 3 · MKO(n0) = 3.
Die zweite Rekurrenz-Gleichung ist einfacher.
Beachte: 3 = 2log2 3· = (2)log2 3 = nlog2 3.
Dabei ist log2 3 ≈ 1,58496.
Deutlich kleiner als n2 !
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS09 – Kapitel 0+1
28
TKO(n0) = 1 und TKO(n) ≤ 3TKO(n/2) + cn, wobei c konstant ist.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS09 – Kapitel 0+1
T (2) ≤
29
3 · TKO(20) + c ·
3j 2−j
0≤j≤−1
T (2 ) ≤
−1
3 · TKO(2
≤ 3 ·1+c·2
)+c·2
0≤j≤−1
≤ 3 · (3 · TKO(2−2) + c · 2−1) + c · 2
= 32 · TKO(2−2) + c · 3 · 2−1 + c · 2
= 3 + c · 2
= 33 · TKO(2−3) + c · 32 · 2−2 + c · 3 · 2−1 + c · 2
..
3j 2−j
≤ 3 · TKO(20) + c ·
< 3 + c ·
j
3
2
( 32 ) − 1
3
2−1
3
1
2
< (1 + 2c) · 3.
0≤j≤−1
Also: T (n) ≤ (1 + 2c)nlog2 3 = O(n1,585).
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS09 – Kapitel 0+1
30
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS09 – Kapitel 0+1
31
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. n0 = 32) die eingebaute MultiplikationsHardware benutzen.
Beispiele:
Zahlen mit 1024 Binärziffern haben gut 300 Dezimalziffern.
(Will man mit so riesigen Zahlen rechnen?)
Ja! – Kryptographie!
Nur für längere Zahlen die KO-Rekursion benutzen.
Welches n0 das optimale ist, hängt von der Hardware und
eventuell von Programmierdetails ab.
Wir betrachten nur die Anzahl der Multiplikationen von 32bit-Zahlen:
MKO
(210) = 3−5 · MKO
(25) = 35 = 243.
Bei Verwendung der Schulmethode (und der Hardware für die
kurzen Zahlen) ergeben sich
(2−5)2 = 1024 Multiplikationen.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS09 – Kapitel 0+1
32
Zahlen mit 32768 Binärziffern haben etwa 9900 Dezimalziffern.
MKO
(215) = 315−5 · MKO
(25) = 310 = 59049.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS09 – Kapitel 0+1
33
Geht es noch besser? Theoretisch ja, praktisch eigentlich kaum.
Mitteilung:
• Schönhage-Strassen (1971): Multiplikation zweier n-BitZahlen mit O(n log n log log n) Gattern.
Bei Verwendung der Schulmethode:
(215−5)2 = 220 Multiplikationen, mehr als 1 Million!
Arnold Schönhage und Volker Strassen: Schnelle Multiplikation großer
Ersparnis: Faktor 18.
Zahlen, Computing 7, 1971, Springer Verlag, S. 281–292
• Fürer (2007): Multiplikation zweier n-Bit-Zahlen mit
∗
O(n log n · 2log n) Gattern.
Martin Fürer: Faster integer multiplication, STOC 2007 Proceedings,
S. 57–66.
Dabei ist log∗ n definiert als die kleinste Zahl mit
log
log. . . log n ≤ 1.
i−mal
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS09 – Kapitel 0+1
34
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS09 – Kapitel 0+1
35
Also: log∗ 2 = 1, log∗ 4 = 2, log∗ 16 = 3, log∗ 65536 = 4,
65536
65536
) = 6, und 22
ist schon
log∗(265536) = 5, log∗(22
eine sehr große Zahl.
(Leider sind beide Algorithmen in der Praxis nicht so sehr
hilfreich.)
Das Master-Theorem
Matrixmultiplikation
Es sei R irgendein Ring.
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 .
– siehe Fließtext-Dokument zum 1. Kapitel –
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.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS09 – Kapitel 0+1
36
Wir nehmen an: n = 2, Zweierpotenz.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS09 – Kapitel 0+1
37
Suggeriert rekursiven Ansatz, in dem 8 Multiplikationen von
( n2 × n2 )-Teilmatrizen durchgeführt werden.
Eingabe: n × n-Matrizen A, B.
Falls n ≤ n0: Berechne A · B mit der direkten Methode.
n30 Multiplikationen.
Einfache Analyse ergibt: n3 Multiplikationen in R, kein
Gewinn.
Falls n > n0:
(Master-Theorem: O(n3).)
Zerlege A, B in jeweils 4 quadratische ( n2 × n2 )-Teilmatrizen:
C D
G H
A=
,
B=
E F
K L
Dann (leicht zu sehen):
CG + DK CH + DL
A·B =
EG + F K EH + F L
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS09 – Kapitel 0+1
38
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS09 – Kapitel 0+1
39
Strassen-Trick:
auskommen.
Man
kann
mit
7
Multiplikationen
M (1) = 1;
P1 = C(H − L)
P2 = (C + D)L
P3 = (E + F )G
P4 = F (K − G)
M (n) = 7M (n/2).
P5 = (C + F )(G + L)
P6 = (D − F )(K + L)
P7 = (C − E)(G + H)
Für n = 2:
M (2) = 7M (2−1) = . . . = 7M (1) = 7.
7 = 2 log2 7 = nlog2 7 mit log2 7 ≈ 2,81.
Dann:
AB =
Aufwandsanalyse (einfachst):
Für n0 = 1, M (n) = Anzahl der Ringmultiplikationen.
P1 + P2
P 5 + P4 − P 2 + P6
P3 + P4
P 1 + P5 − P3 − P7
Aufwandsanalyse (etwas komplizierter): Ringadditionen
A(1) = 0;
Von Hand nachzukontrollieren!
A(n) ≤ 7A(n/2) + cn2 (für eine Konstante c).
18 Additionen.
Rechnung wie bei Zahlen-Multiplikation ergibt:
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS09 – Kapitel 0+1
40
A(2) ≤ 7 · A(2−1) + c · (22)
= c·4
0≤j≤−1
= c·
< c·
3
4
Falls n ≤ n0:
Sortiere mit einem naiven Algorithmus (Insertion Sort).
0≤j≤−1
j
7
4
Sonst:
k := n/2.
Sortiere a1, . . . , ak (erste Hälfte) rekursiv, Ergebnis b1, . . . , bk ;
sortiere ak+1, . . . , an (zweite Hälfte) rekursiv, Ergebnis
bk+1, . . . , bn.
4
< c · 7 .
3
Mische“ die Folgen b1, . . . , bk und bk+1, . . . , bn zu einer sor”
tierten Folge zusammen
Wieder O(nlog2 7)! Alternative: Master-Theorem.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS09 – Kapitel 0+1
41
Um n Zahlen a1, . . . , an zu sortieren, geht man so vor:
( 7 ) − 1
4 47
4−1
7
Effiziente Algorithmen – SS09 – Kapitel 0+1
Mergesort:
≤ 72 · A(2−2) + c · 7 · (22)−1 + c · (22)
..
0
)
+c
·
7j (22)−j
≤ 7 · A(2
=0
FG KTuEA, TU Ilmenau
( Reißverschlussverfahren“), Aufwand: ≤ n − 1 Vergleiche.
”
42
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS09 – Kapitel 0+1
43
Analyse über Rekurrenzungleichungen“: Wir zählen nur
”
Vergleiche.
Beweisansatz:
Man beweist mit Induktion über = 1, 2, 3, . . ., dass folgendes
gilt:
C(n) = Anzahl der Vergleiche beim Sortieren von n Eingaben,
schlechtester Fall.
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
C(1) = 0, C(2) = 1, C(3) = 3.
Für n ∈ {2−1, . . . , 2} gilt C(n) ≤ n − 2 + 1.
...
...
(Dabei benutzt man, dass für n = 2 gilt:
n − 2 + 1 = n( + 1) − 2+1 + 1.)
Merke:
C(n) ≤ C(n/2) + C(n/2) + n − 1.
log n
Lösung: C(n) ≤ nlog n − (2
FG KTuEA, TU Ilmenau
Bei Mergesort:
C(n) ≤ n log n.
− 1).
Effiziente Algorithmen – SS09 – Kapitel 0+1
44
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS09 – Kapitel 0+1
45
Analyse: Wir nehmen an, alle Schlüssel sind verschieden.
Erinnerung: Quicksort
Falls n = 1, ist nichts zu tun.
Weiter nehmen wir an, jede der n! Anordnungen sind gleich
wahrscheinlich, und berechnen die erwartete Anzahl A(n)
von Vergleichen.
Falls n = 2, sortiere mit einem Vergleich. – Sonst:
Falls n ≤ 1: kein Vergleich. Falls n = 2: 1 Vergleich. – Sonst:
Wähle ein Element x ∈ {a1, . . . , an} als partitionierendes
Element. (Z.B.: x = a1; x = Median von {a1, an/2, an};
x = ai mit i zufällig.)
Das Aufteilen in zwei Folgen kostet exakt n − 1 Vergleiche.
Gegeben: Folge (a1, . . . , an).
Zerlege (a1, . . . , an) in eine Teilfolge b1, . . . , bp−1, alle ≤ x, in
das Element x, und eine Teilfolge cp+1, . . . , cn, alle ≥ x.
1 (A(i − 1) + A(n − i)), n ≥ 1.
n
1≤i≤n
Ausgabe: Die Folge (d1, . . . , dp−1, x, ep+1, . . . , en).
Effiziente Algorithmen – SS09 – Kapitel 0+1
Resultierende Rekursionsgleichung:
A(n) = n − 1 +
Sortiere diese beiden Folgen rekursiv,
Ergebnis (d1, . . . , dp−1) und (ep+1, . . . , en).
FG KTuEA, TU Ilmenau
Die Position p von x nimmt jeden Wert i in {1, . . . , n} mit
derselben Wahrscheinlichkeit an.
Hat nicht die gewohnte Form! Master-Theorem nicht anwendbar.
46
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS09 – Kapitel 0+1
47
D.h.: nA(n) = (n + 1)A(n − 1) + 2(n − 1).
1 A(n) = n − 1 +
(A(i − 1) + A(n − i)), n ≥ 1.
n
Teilen durch n(n + 1) liefert:
1≤i≤n
Die ersten Summanden durchlaufen A(0), . . . , A(n − 1), die
zweiten durchlaufen A(n − 1), . . . , A(0).
A(n) = n − 1 +
A(n − 1)
2
2
A(n)
=
+
−
.
n+1
n
n + 1 n(n + 1)
2 A(i), n ≥ 1.
n
0≤i<n
Tricks: Multiplizieren mit n, Subtrahieren der Gleichung für
n − 1 von der für n:
nA(n)−(n−1)A(n−1) = n(n−1)−(n−1)(n−2)+2A(n−1),
n ≥ 1.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS09 – Kapitel 0+1
48
2≤i≤n+1
2
1
−2
.
i
i(i + 1)
O.B.d.A.: Alle Einträge verschieden.
2≤i≤n
A(n)
1
= 2(Hn+1 − 1) − 2 · (1 −
).
n+1
n+1
⇒ A(n) = 2(n + 1)(Hn+1 − 2) + 2 = 2(n + 1)Hn − 4n.
⇒
Dabei ist Hn = 1 + 12 + · · · + n1 ∈ [ln n + 12 , ln n + 1]
(n-te harmonische Zahl).
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS09 – Kapitel 0+1
49
Gegeben ist eine Folge (a1, . . . , an) von n Objekten aus D
(in Array oder als Liste), sowie eine Zahl k, 1 ≤ k ≤ n.
Kann man (mit A(1) = 0) leicht durch Summieren lösen:
Effiziente Algorithmen – SS09 – Kapitel 0+1
Problem: Auswahl – Selection“
”
A(n − 1)
2
2
A(n)
=
+
−
.
n+1
n
n + 1 n(n + 1)
A(n)
=
n+1
FG KTuEA, TU Ilmenau
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 Einträgen ist das
Element mit Rang n/2.
Einfache Lösung: Sortiere, mit Ergebnis (b1, . . . , bn), nun wähle
x = bk .
Kosten: O(n log n) vom Sortieren.
50
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS09 – Kapitel 0+1
51
Algorithmus BFPRT(a1, . . . , an, k)
Ziel: Ein Algorithmus mit Aufwand O(n).
(Erfinder: M. Blum, R. W. Floyd, V. R. Pratt, R. L. Rivest, R.
E. Tarjan: lauter Pioniere der Algorithmik!)
Ansatz: Divide-and Conquer!
Wenn n ≤ n0 (legen wir später fest): Sortiere mit Mergesort,
fertig.
Wenn k = 1 oder k = n: Suche Minimum oder Maximum mit
n − 1 Vergleichen.
Sonst: Zerlege (a1, . . . , an) beliebig in m = n/5 Gruppen
G1, . . . , Gm der Größe 4 oder 5.
Bestimme in jeder Gruppe Gj den Median (von 4 oder 5
Elementen) xj . (Dies lässt sich mit maximal 7 Vergleichen
erreichen – Übung!) – Kosten: ≤ 7n/5 Vergleiche.
Rekursiv: Bestimme mit BFPRT(x1, . . . , xm, m/2)
den Median z der m Mediane {x1, . . . , xm}.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS09 – Kapitel 0+1
52
Bestimme (mit n − 1 Vergleichen) den Rang von z in der
Eingabefolge (a1, . . . , an).
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS09 – Kapitel 0+1
Spalten: Gruppen nach Umsortieren, Kriterium:
A:
53
m j >/=/<z
garantiert >= z
1. Fall: = k. Dann fertig, die Ausgabe ist z.
2. Fall: > k. Dann sind bei der Suche nach dem Element
mit Rang k Elemente ≥ z irrelevant: man kann sie weglassen.
Definiere A := {ai | mj ≥ z und ai ≥ mj und ai in Gruppe Gj }.
z
Dann sind alle Elemente von A mindestens so groß wie z.
Die Elemente von A kann man bei der weiteren Suche weglassen;
es gibt davon |A| ≥ 3m/2 ≥ 3n/10 viele.
Rufe BFPRT(b1, . . . , bn , k) rekursiv auf den verbleibenden
n ≤ 7n/10 Elementen b1, . . . , bn auf.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS09 – Kapitel 0+1
54
B:
FG KTuEA, TU Ilmenau
garantiert <= z
Effiziente Algorithmen – SS09 – Kapitel 0+1
55
3. Fall: < k. Dann kann man bei der Suche nach dem
Element mit Rang k Elemente ≤ z weglassen.
Laufzeitanalyse: Die Laufzeit ist proportional zur Anzahl der
durchgeführten Vergleiche.
Definiere B := {ai | mj ≤ z und ai ≤ mj und ai in Gruppe Gj }.
Wir definieren:
Dann sind alle Elemente von B höchstens so groß wie z.
C(n) := maximale Anzahl der Vergleiche bei Aufruf Algorithmus BFPRT(a1, . . . , ap, k), p ≤ n, 1 ≤ k ≤ p.
Alle Elemente von B kann man bei der weiteren Suche weglassen;
es gibt davon |B| ≥ 3m/2 − 4 ≥ 3n/10 − 4 viele.
Rufe BFPRT(b1, . . . , bn , k − |B|) rekursiv auf den verbleibenden n ≤ 7n/10 + 4 Elementen b1, . . . , bn auf.
(Durch das p ≤ n“ wird die Funktion C(n) monoton.)
”
Die Anzahl C(n) der Vergleiche im Algorithmus gehorcht der
folgenden Rekurrenzungleichung
4
12
(benutze 7n/5 + n − 1 < 12
5 n + 7 · 5 − 1 < 5 n + 5):
Ende Algorithmus
C(n) ≤ n log n, für n ≤ n0;
Korrektheit: ergibt sich aus der begleitenden Überlegung.
C(n) ≤ C(n/5) + C(7n/10 + 4) + 12n/5 + 5,
für n > n0.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS09 – Kapitel 0+1
56
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS09 – Kapitel 0+1
57
Wir behaupten: C(n) ≤ cn für alle n und eine passende
Konstante c.
Wir wählen c so, dass cn/10 ≥ 5c + 12n/5 + 5 ist, was für
c ≥ 25 und n ≥ n0 = 2500 der Fall ist (nachrechnen!).
Die n ≤ n0 werden erledigt, indem man c ≥ log n0 wählt.
Für ein solches c lässt sich der Induktionsschritt durchführen;
damit gilt die Behauptung C(n) ≤ cn für alle n.
Konkret: n0 = 2500; dann genügt c ≥ 13 auf jeden Fall.
Nun sei n > n0. Wir rechnen:
Wir haben gezeigt:
Satz
C(n) ≤ C(n/5) + C(7n/10 + 4) + 12n/5 + 5,
Der BFPRT-Algorithmus löst das Auswahlproblem und hat
eine Laufzeit von O(n) im schlechtesten Fall.
I.V.
≤ cn/5 + c(7n/10 + 4) + 12n/5 + 5
≤ cn/5 + c + 7cn/10 + 4c + 12n/5 + 5
≤ cn + (−cn/10 + 5c + 12n/5 + 5).
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS09 – Kapitel 0+1
58
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS09 – Kapitel 0+1
59
Ein randomisierter Algorithmus für das Auswahlproblem.
Falls n ≥ 3:
Ansatz: Wie bei Quicksort.
Wähle ein Element x ∈ {a1, . . . , an} als partitionierendes
Element. (Zum Beispiel: x = ai für ein zufällig gewähltes i.)
Gegeben: Folge (a1, . . . , an), Zahl k, 1 ≤ k ≤ n.
Zerlege (a1, . . . , an) in eine Teilfolge b1, . . . , bp−1, alle ≤ x, in
das Element x, und eine Teilfolge cp+1, . . . , cn, alle ≥ x.
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 zurück.
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 – SS09 – Kapitel 0+1
60
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS09 – Kapitel 0+1
61
Korrektheit: Klar.
Rekurrenzungleichung:
Zu analysieren: (Erwartete) Rechenzeit.
A(2) = 1.
Wir analysieren die erwartete Anzahl von Vergleichen.
Für n ≥ 3: Wir benötigen n − 1 Vergleiche für die Partitionierung und die Vergleiche aus einem rekursiven Aufruf.
Mittelung über die Möglichkeiten für i = Rang(x) = p ergibt:
⎛
⎞
1
A(n, k) ≤ (n−1)+ ⎝
A(n − i, k − i) +
A(i − 1, k)⎠ .
n
A(n, k) := E(#Vergleiche bei Aufruf für ((a1, . . . , an), k))
Es ist möglich, aber etwas kompliziert, A(n, k) genau zu
bestimmen. Wir beschränken uns auf:
A(n) := max{A(n, k) | 1 ≤ k ≤ n}.
1≤i<k
Daraus:
⎛
A(n, k) ≤ (n − 1) +
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS09 – Kapitel 0+1
62
FG KTuEA, TU Ilmenau
1⎝
n
k<i≤n
A(n − i) +
1≤i<k
Effiziente Algorithmen – SS09 – Kapitel 0+1
⎞
A(i − 1)⎠ .
k<i≤n
63
Vermutung: A(n) ≤ cn, für eine Konstante c.
Dies wird durch Induktion bewiesen, die Konstante c wird
gleich passend gewählt.
Für n = 1 und n = 2 ist nichts zu zeigen.
⎛
⎞
1⎝
A(n − i) +
A(i − 1)⎠
n
1≤i<k
k<i≤n
⎛
⎞
I.V.
1
≤ n−1+ ⎝
c(n − i) +
c(i − 1)⎠
n
1≤i<k
k<i≤n
c
(k − 1)(2n − k) (n − k)(k + n − 1)
= n−1+ ·
+
n
2
2
c (k − 1)(2n − k) + (n − k)(k + n − 1)
.
= n−1+ ·
n
2
A(n, k) ≤ (n − 1) +
Nun ist (Analysis!) (k − 1)(2n − k) + (n − k)(k + n − 1) < 32 n2.
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS09 – Kapitel 0+1
64
Damit: A(n, k) ≤ n − 1 + 34 cn < n + 34 cn für jedes k, also
A(n) < n + 34 cn.
Wir wählen c = 4 und erhalten: A(n) < n + 34 · 4n = 4n = cn.
Damit ist die Induktionsbehauptung gezeigt.
Satz
Die erwartete Vergleichsanzahl beim randomisierten SelectionAlgorithmus ist ≤ 4n; die erwartete Rechenzeit ist O(n).
Mitteilung: Die beste Schranke für die erwartete Vergleichsanzahl bei einem Algorithmus für das Auswahlproblem, nämlich
3
2 n + o(n), erreicht ein anderer randomisierter Algorithmus
(siehe Vorlesung Randomisierte Algorithmen“).
”
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS09 – Kapitel 0+1
66
FG KTuEA, TU Ilmenau
Effiziente Algorithmen – SS09 – Kapitel 0+1
65