Modul: Algorithmen und Berechenbarkeit WS2012/13

Modul: Algorithmen und Berechenbarkeit
WS 2012/13
Volker Diekert1
8. Februar 2013
1
Übungen: Alexander Lauser und Armin Weiß
1 / 369
Teil 1: Algorithmen
2 / 369
Landau-Symbole-Oh-oh
Definition:
◮
O(f)
Es gilt g ∈ O(f ), falls
∃c > 0 ∃n0 ∀n ≥ n0 : g (n) ≤ c · f (n).
Also: g wächst nicht schneller als f .
◮
o(f)
Es gilt g ∈ o(f ), falls
∀c > 0 ∃n0 ∀n ≥ n0 : g (n) ≤ c · f (n).
Also: g wächst echt langsamer als f .
3 / 369
Landau-Symbole-Omega-Theta
◮
Ω(f)
g ∈ Ω(f ) ⇔ f ∈ O(g )
Also: g wächst mindestens so schnell wie f .
◮
ω(f)
g ∈ ω(f ) ⇔ f ∈ o(g )
Also: g wächst echt schneller als f .
◮
Θ(f)
g ∈ Θ(f ) ⇔ (f ∈ O(g ) ∧ g ∈ O(f ))
Dies heißt, g und f wachsen asymptotisch gleichschnell.
4 / 369
Reale Rechenzeiten - früher
Eine Eingabe der Länge n werde linear in n Millisekunden verarbeitet.
(Aus dem Buch von Aho, Hopcroft, Ullman, 1974)
Algorithmus
n
n log(n)
n2
n3
2n
1 Minute
Rechenzeit
1 Stunde
Rechenzeit
60.000
4.893
244
39
15
3.6 ∗ 106
200.000
1.897
153
21
Wachstum bei 10-facher
Beschleunigung
∗10
∗10
√ (für große Werte)
∗ √10 (ca. 3.16)
∗ 3 10 (ca. 2.15)
+ log2 (10) (ca. 3.3)
Je schneller der Rechner, desto wichtiger sind effiziente
Algorithmen!
5 / 369
Reale Rechenzeiten - heute?
Es wird hier angenommen, dass ein linearer Algorithmus eine Eingabe
der Länge n in n Mikrosekunden verarbeitet:
Algorithmus
n
n log(n)
n2
n3
2n
1 Minute
Rechenzeit
1 Stunde
Rechenzeit
6, 0 · 107
2, 8 · 106
7.746
391
26
3, 6 · 109
1, 3 · 108
60.000
1.533
32
Wachstum bei 10-facher
Beschleunigung
∗10
∗10
√ (für große Werte)
∗ √10 (ca. 3,16)
∗ 3 10 (ca. 2,15)
+ log2 (10) (ca. 3,32)
Heute immer noch: Je schneller der Rechner, desto mehr
lohnen sich effiziente Algorithmen!
6 / 369
Reale Rechenzeiten
Vergleich (1 Operation = 1 ms) vs. (1 Operation = 1 µs)
Algorithmus
n
n log(n)
n2
n3
2n
1 Minute Rechenzeit
1 OP=1 ms
1 OP=1 µs
6, 0 · 104
4.893
244
39
15
6, 0 · 107
2, 8 · 106
7.746
391
26
1 Stunde Rechenzeit
1 OP=1 ms
1 OP=1 µs
3, 6 · 106
2, 0 · 105
1.897
153
21
3, 6 · 109
1, 3 · 108
60.000
1.533
32
10-fache
Beschl.
∗ 10
∼√∗ 10
∗ √10
∗ 3 10
+ log2 (10)
7 / 369
Komplexitätsmaße
◮
Komplexität im ungünstigsten Fall (worst case).
◮
Komplexität im Mittel (average case) benötigt eine
Wahrscheinlichkeitsverteilung der Eingabe.
Mittlerer Zeitbedarf:
tA,Mittel (n) = E (tA (x), |x| = n)
Dabei sei E (tA (x), |x| = n) der bedingte Erwartungswert von
tA (x) unter der Bedingung |x| = n
8 / 369
Beispiel: Quicksort
Beim Quicksort-Algorithmus ist die Anzahl der Vergleiche im
ungünstigsten Fall tQ (n) ∈ Θ(n2 ).
Mittlerer Zeitbedarf: tA,Mittel (n) = 1.38n log n
9 / 369
Durchschnittsanalyse
Die Durchschnittskomplexitätsanalyse ist oft schwierig.
Gleichverteilung der Eingaben gleicher Länge:
tA,Mittel (n) =
1 X
tA (x)
|Xn |
x∈Xn
mit
Xn := {x ∈ X | |x| = n}
Sinnvoll?
10 / 369
Beispiel binäre Suchbäume
Beispiel 1.1
Gleichverteilung bei binären Suchbäumen:
1 2n
Es gibt n+1
n (= (n + 1)-te Catalansche Zahl) verschiedene
Binärbäume mit n Knoten.
2n
4n
∼√
n
πn
n! ∼
√
2πn
n n
e
√
Gleichverteilung: Mittlere Baumhöhe ist ungefähr n.
Realistischer: eine Verteilung auf der Menge der binären Suchbäume,
die sich durch eine Gleichverteilung von Permutationen ergibt.
Damit: Mittlere Baumhöhe Θ(log(n)). 1 2n
n! wächst wesentlich schneller als n+1
n
11 / 369
Maschinenmodelle: Turingmaschine
Die Turingmaschine (TM) ist ein mathematisch leicht exakt
beschreibbares Berechnungsmodell. Allerdings ist der zeitraubende
Speicherzugriff (Bandzugriff) in der Realität nicht gegeben.
Arbeitet ein Algorithmus auf einer TM schnell, so ist er schnell!
12 / 369
Maschinenmodelle: Registermaschine
x1 x2 x3 x4 x5 x6 x7 x8 x9
.
.
.
Eingabe READ ONLY
Speicher
RAM
0 = Akku
1 = 1.Reg
2 = 2.Reg
3 = 3.Reg
4 = 4.Reg
IC
✲
.
Programm
.
.
y1 y2 y3 y4 y5 y6 y7 y8 y9
.
.
.
Ausgabe WRITE ONLY
13 / 369
Untere Schranken / Beispiel Sortieren
Einer der schwierigen Aspekte der Algorithmentheorie ist die Suche
nach unteren Schranken.
Satz 1.2 (Sortieralgorithmen)
Jeder Sortieralgorithmus, der ausschließlich auf Schlüsselvergleichen
basiert, benötigt Ω(n log n) Vergleiche.
Beweis: Wir fassen Sortieralgorithmen als Entscheidungsbäume auf,
d.h. als Binärbäume, deren inneren Knoten mit Vergleichen der Art
gilt x[i] < x[j]?“ beschriftet sind. Es gibt n! Permutationen von n
”
Elementen. Fasst man jede Permutation als einen Pfad durch einen
Entscheidungsbaum auf, so muss dieser mindestens n! Blätter haben.
Jeder binäre Baum mit n! Blättern hat eine Mindesthöhe von
log(n!) ∈ Ω(n log(n)). Die Höhe des Entscheidungsbaums entspricht
aber dem Zeitaufwand des Algorithmus.
14 / 369
Beispiel Zwei gleiche Zahlen in einem Feld“
”
Sei ein Feld a[1...n] gegeben. Frage: existiert i 6= j mit a[i] = a[j]?
Satz 1.3 (Zwei gleiche Zahlen in einem Feld)
Jeder vergleichsbasierte Algorithmus, der die Existenz von zwei
gleichen Zahlen in einem Feld überprüft, benötigt Ω(n log(n))
Vergleiche.
15 / 369
Lösung einfacher Rekursionsgleichungen
Satz 1.4
Seien a, b ∈ N und b > 1, g : N → N und es gelte die
Rekursionsgleichung:
t(1) = g (1)
t(n) = a · t(n/b) + g (n)
Dann gilt für n = b k (d.h. für k = logb (n)):
t(n) =
k
X
i=0
ai · g
n
bi
.
16 / 369
Beweis des Satzes
k = 0 : Es gilt n =b 0 =
und t(1) = g(1).
P1k−1
n
n
mit Induktion,
k > 0 : Daher t b = i=0 ai · g bi+1
also t(n) = a · t
= a
n
b
k−1
X
i=0
=
=
k
X
i=1
k
X
i=0
+ g (n)
n ai · g
b i+1
ai · g
ai · g
n
bi
n
bi
!
+ a0 g
+ g (n)
n
b0
.
17 / 369
Mastertheorem I
Korollar 1.5 (Mastertheorem I)
Seien a, b ∈ N, mit b > 1 und es gelte die Rekursionsgleichung:
t(n) ∈ a · t(n/b) + Θ(nc )
Dann gilt:
Bemerkung:

c

; falls a < b c
 Θ(n )
Θ(nc log n) ; falls a = b c
t(n) ∈
log a

 Θ(n log
b)
; falls a > b c
log a
log b
= logb a. Falls a > b c , so ist logb a > c.
18 / 369
Beweis Mastertheorem I
Sei g (n) = nc . Damit ist t(n) = nc ·
1. Fall a < b c : t(n) ≤ nc ·
Pk
a i
i=0 ( b c )
nach dem Satz.
∞ X
a i
1
∈ O(nc ).
= nc ·
bc
1 − bac
i=0
Außerdem gilt t(n) ∈ Ω(nc ). Hieraus folgt t(n) ∈ Θ(nc ).
2. Fall a = b c : t(n) = (k + 1) · nc ∈ Θ(nc log n).
19 / 369
Beweis Mastertheorem I
3. Fall a > b c :
k a k+1
X
−1
a i
c ( bc )
=
n
·
a
c
b
bc − 1
i=0
a logb (n) Θ nc · c
b
!
nc · alogb (n)
Θ
b c logb (n)
Θ alogb (n) = Θ b logb (a)·logb (n)
Θ nlogb (a)
t(n) = nc ·
∈
=
=
=
20 / 369
Beispiel Mergesort
Algorithmus 1.1 Mergesort
procedure mergesort(l, r )
var m : integer;
begin
if (l < r ) then
m := (r + l) div 2;
mergesort(l, m);
mergesort(m + 1, r );
mische(l, m, r );
endif
endprocedure
21 / 369
Mastertheorem II
Satz 1.6 (Mastertheorem II)
Sei r > 0,
Pr
i=0 αi
< 1 und für eine Konstante c sei
!
r
X
t(n) ≤
t(⌈αi n⌉) + c · n
i=0
Dann gilt t(n) ∈ O(n).
22 / 369
Beweis Mastertheorem II
Wähle ein ε und ein n0 > 0 so, dass
α
Pi nr 0 ≤ n0 − 1 und
Pr dass
i=0 ⌈αi n⌉ ≤ ( i=0 αi ) · n + r + 1 ≤ (1 − ε)n für alle n ≥ n0 .
Wähle ein γ so, dass c < γε und t(n) < γn für alle n < n0 .
Für den Induktionsschritt (n ≥ n0 ) gilt:
!
r
X
t(n) ≤
t(⌈αi n⌉) + cn
≤
i=0
r
X
i=0
γ⌈αi n⌉
!
+ cn
(mit Induktion)
≤ (γ(1 − ε) + c)n
≤ γn
23 / 369
1. Vorlesung am 23.10.2012
Newsticker am 15.10.12: Der diesjährige Nobelpreis für
”
Wirtschaftswissenschaften geht an die US-Amerikaner Alvin E. Roth
und Lloyd S. Shapley. Damit werde ihr Beitrag zur Theorie stabiler
Zuordnungen und zur Gestaltung ganz bestimmter Märkte gewürdigt.“
Aus der Laudatio: The Gale-Shapley algorithm Analysis of allocation
mechanisms relies on a rather abstract idea. If rational people – who
know their best interests and behave accordingly – simply engage in
unrestricted mutual trade, then the outcome should be efficient. If it
is not, some individuals would devise new trades that made them
better off. An allocation where no individuals perceive any gains from
further trade is called stable. The notion of stability is a central
concept in cooperative game theory, an abstract area of mathematical
economics which seeks to determine how any constellation of rational
individuals might cooperatively choose an allocation. The primary
architect of this branch of game theory was Lloyd Shapley, who
developed its main concepts in the 1950s and 1960s.
24 / 369
Stabile Heirat
Es seien A und B Mengen von je n Personen. Ohne Einschränkung
seien A die Frauen und B die Männer. Jede Person hat eine
Präferenzliste der Personen vom anderen Geschlecht. Für a ∈ A
können wir uns die Präferenzliste P(a) als eine lineare Ordnung
b1 > · · · > bn mit B = { b1 , . . . , bn } vorstellen. Wenn bi in der
Ordnung vor bj steht, also i < j gilt, so bevorzugt a den Mann bi .
Analog verfügt jeder Mann b ∈ B über eine Präferenzliste P(b).
Treffen eine Frau a und ein Mann b aufeinander und ziehen diese
beiden Personen wechselseitig vor ihren augenblicklichen Partnern vor,
so tun sie sich zusammen, auch wenn es Scheidungen kommt.
Die Heirat (oder das Matching M) heißt stabil, wenn es zu keinen
Scheidungen kommt.
25 / 369
Scheidungen und stabile Heirat
Es kommt zu einer Scheidung, wenn es zwei Paare (a, b ′ ), (a′ , b) gibt
mit b > b ′ in der Präferenz von a und a > a′ in der Präferenz von b.
Dann lassen sich nämlich a und b scheiden und bilden ein neues Paar
(a, b).
26 / 369
Vermeidung von Scheidungen: Gale, Shapley 1962
Satz 2.1 (Gale, Shapley 1962)
Eine stabile Heirat existiert und kann in maximal n2 Runden wie folgt
berechnet werden.
1. Zu Anfang ist niemand verlobt oder verheiratet.
2. Solange noch ein unverlobter Mann b ∈ B existiert, macht er der
Dame a ∈ A einen Antrag, die in der Präferenzliste am weitesten
vorne unter den noch nicht gefragten Frauen steht.
3. Die Frau nimmt den Antrag und verlobt sich mit ihm, wenn sie
noch keinen Partner hat, oder sie den Antragsteller b ihrem
derzeitig Verlobten vorzieht. Gegebenenfalls wird also eine
Verlobung gelöst, um eine andere einzugehen.
4. Sind alle Männer verlobt, so heiraten die Verlobten
untereinander. Dies ist die stabile Heirat.
27 / 369
Zwei Paare
Bevor wir in den Beweis einsteigen wollen wir die Situation von zwei
Paaren analysieren. Es gibt also zwei Frauen a, a′ und zwei Männer
b, b ′ . Haben beide Frauen ihre Präferenz für b, so ist b in der guten
Position, dass er sich seine Partnerin frei wählen kann. Sagen wir, er
wählt a. Der Mann b ′ kann Glück haben, dass a′ seine Favoritin ist,
aber a′ hat sicher nur die zweite Wahl getroffen. Haben die Männer
identische Präferenzen, so ist die Situation symmetrisch. Interessanter
ist, wenn sich die Präferenzen jeweils überkreuzen. Sagen wir a hat als
Favorit b und a′ hat als Favorit b ′ . Ist a auch die erste Wahl von b
oder ist a′ auch die erste Wahl von b ′ , so ist die Paarbildung
(a, b), (a′ , b ′ ) stabil und die einzige Möglichkeit einer stabilen Heirat.
Es verbleibt der Fall, dass a′ die erste Wahl von b und a die erste Wahl
von b ′ . Jetzt kommt es entscheidend darauf an, wer die Anträge stellt.
Beide Paarbildungen (a, b), (a′ , b ′ ) und (a, b ′ ), (a′ , b) stabil. Stellen
also die Männer die Anträge, so setzen sich Ihre Präferenzen durch.
Dies ist die Paarbildung (a, b ′ ), (a′ , b), stellen die Frauen die Anträge,
so setzen sie sich durch. Die Paarbildung ist dann (a, b), (a′ , b ′ ).
28 / 369
Beweis
Da es mindestens so viele Frauen wie Männer gibt, sind am Ende alle
Männer verheiratet. Wegen |A| = |B| = n sind also alle Personen
verheiratet.
29 / 369
Beweis
Wir sagen, dass ein Paar (a, b) ∈ A × B realisierbar ist, wenn (a, b) in
einer stabilen Heirat vorkommt.
Wir sagen, dass ein Paar (a, b) ∈ A × B instabil ist, wenn (a, b) in
keiner stabilen Heirat vorkommt.
Behauptung: Angenommen, a hat im Gale-Shapley-Verfahren einen
Antrag von b abgelehnt oder b verlassen. Dann ist das Paar (a, b)
instabil.
Beweis: Betrachte die zeitlich erste Situation, in der eine Frau a einen
Mann b ablehnt oder verlässt, obwohl das Paar (a, b) in einer stabilen
Heirat M realisierbar ist.
Der Grund ist beiden Fällen ein Mann b ′ für den die Präferenz von a
höher ist. Es kann sein, dass b ′ von anderen Frauen Absagen erhielt
oder verlassen worden ist. Aber keine dieser Partnerschaften war
stabil, denn das erste realisierbare Paar wird nach Annahme ist (a, b).
Also gilt (a, b), (a′ , b ′ ) ∈ M und aus Sicht von b ′ gilt a > a′ . Treffen
also (a, b), (a′ , b ′ ) aufeinander, so verlassen a und b ′ ihre Partner und
bilden ein neues Paar (a, b ′ ).
30 / 369
Folgerungen aus der Behauptung
Gale-Shapley berechnet eine stabile Heirat: Am Ende sind alle
Personen verheiratet. Angenommen, diese Heirat wäre nicht stabil.
Dann gibt es zwei Paare (a, b) und (a′ , b ′ ), wobei b die Frau a′ der
aktuellen Partnerin a vorzieht. Dann hatte jedoch a′ vor der
Verlobung von b und a entweder einen Antrag von b abgelehnt oder
ihn verlassen. Der Grund hierfür war ein Mann b ′′ für den sie eine
höhere Präferenz hat als für b. Da sich Frauen im Verlaufe des
Verfahrens nur verbessern, ist die Präferenz auch von ihrem aktuellen
Partner b ′ in jedem Fall höher als für b. Damit kann es zu keinen
Scheidungen kommen und das Verfahren ist stabil.
Das Verfahren ist für die Männer optimal, denn sie erhalten jeweils die
Partnerin, die die höchste Präferenz unter allen Frauen hat, mit denen
überhaupt eine stabile Paarbildung möglich ist.
Dabei kommt es nicht auf die Reihenfolge der Anträge an. Die
Männer können sich sogar Zeit lassen.
Dies ändert sich, wenn Frauen ihre Präferenzen nur partiell geordnet
haben. Dann ist es wichtig, wer zu erst den Antrag stellt.
31 / 369
2. Vorlesung am 25.10.2012
Literatur etwa zum stabilen Matching findet sich leicht, etwa:
http://www.cs.princeton.edu/~wayne/kleinberg-tardos
Wiederholungen, Ergänzungen, Fragen, Ausblick.
Mathematische Definitionen: Graphen
32 / 369
Entwurfstrategien
Gierige Algorithmen – Greedy Algorithms
33 / 369
Optimalitätsprinzip
Greedy ( gierig“) bezeichnet Lösungsstrategien, die auf der
”
schrittweisen Berechnung von Teillösungen (lokalen Optima) basieren.
Dieses Verfahren eignet sich für Probleme, bei denen jede Teilfolge
einer optimalen Folge auch optimal ist (Optimalitätsprinzip).
34 / 369
Wiederholung aus DSAlg
Kürzeste Wege
Graph: G = (V , E , γ) mit
V die Knotenmenge,
E ⊆ V × V die gewichteten Kanten,
γ : E → N0 die Gewichtsfunktion.
Das Gewicht eines Pfades ist gleich der Summe der Kantengewichte.
Sei d(u, v ) für u, v ∈ V das Minimum der Gewichte aller Pfade von u
nach v (mit der üblichen Konvention, dass d(u, v ) = ∞ gilt, falls kein
Pfad von u nach v existiert).
Die Aufgabe ist es, bei gegebenen Graphen G und Knoten u ∈ V für
jedes v ∈ V einen Pfad
P u = u0 , u1 , u2 , . . . , un−1 , un = v mit
minimalem Gewicht ni=1 γ(ui−1 , ui ) = d(u, v ) zu bestimmen.
35 / 369
Beispiel Dijkstra-Algorithmus
Startknoten
0
1
3
∞
1
6
3
8
2
13
4
∞
3
∞
6
∞
36 / 369
Beispiel Dijkstra-Algorithmus
Startknoten
0
1
3
1
7
6
3
8
2
13
4
∞
3
∞
6
14
37 / 369
Beispiel Dijkstra-Algorithmus
Startknoten
0
1
3
1
7
6
3
8
2
4
11
7
13
3
6
14
38 / 369
Beispiel Dijkstra-Algorithmus
Startknoten
0
1
3
1
7
6
3
8
2
4
11
7
13
3
6
13
39 / 369
Beispiel Dijkstra-Algorithmus
Startknoten
0
1
3
1
7
6
3
8
2
4
9
7
13
3
6
13
40 / 369
Beispiel Dijkstra-Algorithmus
Startknoten
0
1
3
1
7
6
3
8
2
4
9
7
13
3
6
12
41 / 369
Beispiel Dijkstra-Algorithmus
Startknoten
0
1
3
1
7
6
3
8
2
4
9
7
13
3
6
12
42 / 369
Komplexität Dijkstra
Folgende Operationen werden benötigt:
insert
decrease-key
delete-min
Füge ein neues Element in R ein.
Verringere den Schlüsselwert eines Elements von R
(und erhalte die Eigenschaften des Datentyps R).
Suche ein Element mit minimalem Schlüsselwert
und entferne dieses aus R (und erhalte die Eigenschaften des Datentyps R).
43 / 369
Pseudocode und Komplexität vom Dijkstra-Algorithmus
Eingabe:
V = Knoten, E = Kanten, γ : E → N Gewicht
B := ∅; R := {u}; U := V \ {u}; v (u) := nil; D(u) := 0;
while (R 6= ∅) do
x := delete-min(R);
B := B ∪ {x};
forall (x, y ) ∈ E do
if y ∈ U then
U := U \ {y }; v (y ) := x; D(y ) := D(x) + γ(x, y );
insert(R, y , D(y ));
elsif D(x) + γ(x, y ) < D(y ) then
v (y ) := x; D(y ) := D(x) + γ(x, y );
decrease-key(R, y , D(y ));
endif
endfor
endwhile
44 / 369
Problem negativer Kantengewichte
Startknoten
0
1
1
6
3
∞
3
8
2
-13
4
∞
∞
3
6
∞
45 / 369
Problem negativer Kantengewichte
Startknoten
0
1
1
6
3
7
3
8
2
-13
4
∞
∞
3
6
∞
46 / 369
Problem negativer Kantengewichte
Startknoten
0
1
1
6
3
7
3
8
2
-13
4
11
7
3
6
∞
47 / 369
Problem negativer Kantengewichte
Startknoten
0
1
1
6
3
7
3
8
2
-13
4
11
7
3
6
13
48 / 369
Problem negativer Kantengewichte
Startknoten
0
1
1
6
3
7
3
8
2
-13
4
9
7
3
6
13
49 / 369
Problem negativer Kantengewichte
Startknoten
0
1
1
6
3
7
3
8
2
-13
4
9
7
3
6
12
50 / 369
Problem negativer Kantengewichte
Startknoten
0
1
1
6
3
7
3
8
2
-13
4
9
7
3
6
12
51 / 369
Problem negativer Kantengewichte
Startknoten
0
1
−∞
3
−∞
6
3
8
2
4
Negativer Zyklus
-13
7
−∞
3
6
−∞
52 / 369
Lösung: Bellman-Ford-Algorithmus
Wikipedia sagt:
Der Algorithmus von Bellman und Ford (nach seinen Erfindern
Richard Bellman und Lester Ford) dient der Berechnung der kürzesten
Wege ausgehend von einem Startknoten in einem kantengewichteten
Graphen. Anders als beim Algorithmus von Dijkstra, dürfen hier die
Gewichte der Kanten auch negativ sein. Kreise negativen Gewichtes,
die vom Startknoten aus erreichbar sind, müssen jedoch
ausgeschlossen werden, denn andernfalls könnten diese beliebig oft
durchlaufen und somit Wege immer geringeren Gewichts konstruiert
werden. Der Bellman-Ford-Algorithmus kann das Vorhandensein von
Kreisen negativen Gewichtes erkennen.
53 / 369
Minimale Aufspannende Bäume
Definition 3.1
Ein Graph G = (V , E ) heißt zusammenhängend, wenn je zwei Knoten
durch einen Pfad verbunden sind.
Definition 3.2
Ein Baum ist ein zusammenhängender, kreisfreier, ungerichteter
Graph.
Bemerkung 3.3
Jeder Baum mit n Knoten besitzt genau n − 1 Kanten.
Definition 3.4
Ein minimaler aufspannender Baum (MSB, engl. minimal spanning
tree, MST) zu einem gewichteten Graphen G = (V , E , γ) ist ein
Baum T P
= (V , T , γ|T ) mit T ⊆ E mit minimalem Gewicht
γ(T ) := e∈T γ(e).
54 / 369
Beispiel Prim-Algorithmus, 1
Startknoten
1
3
6
8
2
4
13
3
6
55 / 369
Beispiel Prim-Algorithmus, 2
Startknoten
1
3
6
8
2
4
13
3
6
56 / 369
Beispiel Prim-Algorithmus, 3
Startknoten
1
3
6
8
2
4
13
3
6
57 / 369
Beispiel Prim-Algorithmus, 4: Decrease Key
Startknoten
1
3
6
8
2
4
13
3
6
58 / 369
Beispiel Prim-Algorithmus, 5
Startknoten
1
3
6
8
2
4
13
3
6
59 / 369
Beispiel Prim-Algorithmus, 6
Startknoten
1
3
6
8
2
4
13
3
6
60 / 369
Beispiel Prim-Algorithmus, 7
Startknoten
1
3
6
8
2
4
13
3
6
61 / 369
Beispiel Prim-Algorithmus, 8
Startknoten
1
3
6
8
2
4
13
3
6
62 / 369
Beispiel Prim-Algorithmus, 9
Startknoten
1
3
6
8
2
4
13
3
6
63 / 369
Prim-Algorithmus
Eingabe:
V = Knoten, E = Kanten, γ : E → N Gewicht
Wähle ein x0 ∈ V ; B := {x0 }; R := ∅, U := V \ {x0 }; T := ∅;
forall (x0 , y ) ∈ E do
U := U \ {y }; v (y ) := x0 ; D(y ) := γ(x, y ); insert(R, y , D(y ))
endfor
while R 6= ∅ do
x := delete-min(R); B := B ∪ {x}; T := T ∪ {v (x)x};
forall (x, y ) ∈ E , y 6∈ B do
if y ∈ U then
U := U \ {y }; v (y ) := x; D(y ) := γ(x, y ); insert(R, y , D(y ));
elsif γ(x, y ) < D(y ) then
v (y ) := x; D(y ) := γ(x, y ); decrease-key(R, y , D(y ));
endif
endfor
endwhile
return T
64 / 369
Korrektheit des Prim-Algorithmus
Idee: Austauschsatz
Bi−1
y′
Ri−1
∈T
y
v (x)
6∈ T
x
65 / 369
Bemerkungen zum Dijkstra-und Algorithmus
1. Randverwaltung als Feld ergibt ein Aufwand von O(n2 ).
2. Für dünne Graphen (O(e) ⊆ o(n2 / log n)) ist es günstiger, den
Rand R in einer Prioritätswarteschlange (Heap) zu verwalten.
Der Aufwand des Algorithmus wird damit nach der obigen
Herleitung O(e log n + n log n) ⊆ O(e log n).
3. Bei Verwendung der Datenstruktur der Fibonacci-Heaps ergibt
sich ein Aufwand von O(e + n log n). (→ später)
4. Der Dijkstra-Algorithmus liefert für negative Kantengewichte
nicht nicht notwendigerweise ein korrektes Ergebnis.
5. Der Prim-Algorithmus liefert auch bei negativen
Kantengewichten ein korrektes Ergebnis.
66 / 369
3. Vorlesung, 30.10.12
Thema: Minimale Schnitte
Das Ziel ist die Berechnung eines Schnittes C mit minimalem Gewicht.
Der nachfolgende Algorithmus zur Berechnung eines minimalen
Schnittes stammt von Mechthild Stoer und Frank Wagner (1994).
Erschienen als Zeitschriftenversion in Journal of the ACM (1997)
585-591.
Der Stoer-Wagner-Algorithmus benutzt in n Runden jeweils eine
Unterprozedur, die genau dem Schema im Dijkstra- bzw.
Prim-Algorithmus entspricht.
67 / 369
Minimale Schnitte
Sei G = (V , E , γ) ein ungerichteter Graph
γ : V2 → N das Kantengewicht mit E = { vw | γ(vw ) > 0 }.
Ṡ
Ein Schnitt C = (C1 , C2 ) ist eine Partition: V = C1 C2 mit
C1 6= ∅ =
6 C2 und C1 ∩ C2 = ∅ .
Das Gewicht g (C ) von C ist die Summe der Gewichte der Kanten, die
die beiden Teilmengen trennen:
g (C ) =
X
γ(vw )
v ∈C1 ,w ∈C2
Ein s-t-Schnitt ist ein Schnitt (C1 , C
2 ) mit s ∈ C1 und t ∈ C2 .
P
Für A ⊆ V , v ∈ V setze g (A, v ) = a∈A γ(av ).
Oder einheitlich:
X
γ(ab)
g (A, B) =
a∈A,b∈B
68 / 369
Bemerkungen
Setze g (G ) = min { g (C ) | C ist Schnitt }.
◮
g (G ) = 0 gdw. E = ∅ oder G ist nicht zusammenhängend.
Ab jetzt sei E 6= ∅ und G zusammenhängend.
◮
min { γ(e) | e ∈ E } ≤ g (G ) ≤ min { γ(V − x, x) | x ∈ V }
◮
Ab drei Knoten gilt
g (G ) ≤ min { γ(V − x, x) + γ(V − y , y ) − 2γ(xy ) | xy ∈ E }
69 / 369
Bemerkungen
Sei jetzt g (G ) = g (C ) für einen Schnitt C = (C1 , C2 ).
◮
Dann sind C1 und C2 zusammenhängend.
Sei e = xy ∈ E mit x ∈ C1 . Dann gibt es zwei Fälle:
1. Es ist auch y ∈ C1 .
Dann: g (G ) = g (G /(x = y )) (Kantenkontraktion).
2. Es ist y ∈ C2 .
Dann: γ(e) ≤ g (G ) ≤ g (G − e) + γ(e).
Denn die Schnitte (C1 , C2 ) von G und G − e sind identisch, nur ihr
Gewicht ist unterschiedlich.
Ist (C1 , C2 ) minimal für G − e mit x, y ∈ C1 , so ist dieser auch
minimal für G . Der zweite Fall ist klar.
70 / 369
Phasen
Der Algorithmus arbeitet in Phasen.
1) Berechne für zwei Punkte s, t ∈ V , s 6= t einen minimalen
s-t-Schnitt Cphase .
Achtung: Die Punkte s und t liegen vorher nicht fest!
2) Verschmelze s und t zu einem neuen Punkt {s, t}:
Die Kanten zwischen s und t werden gelöscht und für x ∈
/ {s, t} setzt
man γ({s, t}x) = γ(sx) + γ(tx).
Der neue Graph heiße G /(s = t).
3) Rekursion: Sei C ′ der rekursiv berechnete Schnitt in G /(s = t).
Dann ist C ′ ein minimaler Schnitt von G unter der Nebenbedingung,
dass C ′ die Knoten s und t nicht trennt.
Der minimale Schnitt ist das Minimum von g (Cphase ) und g (C ′ ).
71 / 369
Minimale s-t-Schnitte
Es kommt also im Wesentlichen darauf an, den minimalen s-t-Schnitt
für gewisse Knoten s, t ∈ V , s 6= t zu berechnen. Diese Phase verläuft
analog zum Dijkstra- bzw. Prim-Algorithmus.
Zu Beginn der Phase gelte B = {v1 } und R = V \ {v1 }. Die Knoten
aus B werden Baumknoten und die Knoten aus R Randknoten
genannt.
P
Für einen Randknoten v ∈ R sei stets g (v ) = x∈B γ(xv ).
(Gibt es keine Kante zwischen B und v , so hat diese Summe den
Wert Null. Damit ist der Wert g (v ) = γ(v1 v ) in der Zeit O(|R|) für
den Rand initialisiert.)
72 / 369
while |R| > 1 do
Zu Beginn jeder Schleife wird ein delete max ausgeführt. Dies
bestimmt einen Knoten v ∈ R mit g (v ) ≥ g (w ) ∀w ∈ R und entfernt
v aus R.
Es wird B um v ergänzt (v wird also ein Baumknoten) und die
Schlüsselwerte werden mit increase key vergrößert:
Für w ∈ R \ {v } setzt man g (w ) := g (w ) + γ(vw ). Eine Invariante
ist also
∀w ∈ R : g (w ) = g (B, w )
73 / 369
Termination
Die Schleife wird solange durchlaufen,
P bis der Rand nur noch einen
Knoten t enthält. Dann gilt g (t) = vt∈E γ(vt), d.h. g (t) ist die
Summe der Gewichte aller von t ausgehenden Kanten. Sei s der
Knoten, der unmittelbar vor t zum Baumknoten wurde. Dann
definiert die Zerlegung (V \ {t}, {t}) einen s-t-Schnitt Cphase mit
dem Gewicht g (t).
74 / 369
Korrektheitslemma
Lemma 4.1
Der Schnitt Cphase ist ein minimaler s-t-Schnitt im Eingabegraphen
der Phase.
Beweis:
Sei v1 , v2 , . . . , vn eine Anordnung der Knoten in der Reihenfolge, in
der sie zu Baumknoten wurden. Es gilt vn−1 = s, vn = t. Sei
C = (C1 , C2 ) ein minimaler s-t-Schnitt mit s ∈ C1 , t ∈ C2 .
Wir zeigen:
g (Cphase ) ≤ g (C )
75 / 369
g (Cphase ) ≤ g (C )
In der Folge v1 , . . . , vn−1 , vn wird ein Knoten vi aktiv genannt, falls C
ein vi−1 -vi -Schnitt ist.
Da C ein s-t-Schnitt ist, ist insbesondere vn = t aktiv.
Sei vi aktiv; setze B(i) = {v1 , . . . , vi−1 } und betrachte den durch
B(i) ∪ {vi } induzierten Untergraphen. Durch Einschränkung definiert
C auf diesem Untergraphen einen Schnitt. Diesen bezeichnen wir mit
C (i) und das Gewicht mit g (C (i)).
Da t = vn aktiv ist und g (Cphase ) = g (B(n), t) sowie C (n) = C
gelten, genügt es, die Behauptung g (B(i), vi ) ≤ g (C (i)) für alle
aktiven Knoten vi zu zeigen.
Für den bzgl. der obigen Folge ersten aktiven Knoten vi gilt
g (B(i), vi ) = g (C (i)), denn die durch C induzierte Partition ist
({v1 , . . . , vi−1 }, {vi }). Dies ist die Induktionsverankerung.
76 / 369
Fortsetzung: Beweis
Sei jetzt vi ein aktiver Knoten für den die Behauptung richtig ist und
vj der nächste auf vi folgende aktive Knoten. Dann gilt 1 < i < j ≤ n.
Zu zeigen ist: g (B(j), vj ) ≤ g (C (j)).
Es gilt zunächst:
g (B(j), vj ) = g (B(i), vj ) + g ({vi , . . . , vj−1 }, vj )
Da der Knoten vi vor vj gewählt wurde, gilt g (B(i), vj ) ≤ g (B(i), vi )
und nach Induktion gilt g (B(i), vi ) ≤ g (C (i)). Alle Kanten zwischen
{vi , . . . , vj−1 } und vj sind Schnittkanten und tragen somit zum
Gewicht von C (j) bei. Daher
g (C (i)) + g ({vi , . . . , vj−1 }, vj ) ≤ g (C (j)), und
insgesamt g (B(j), vj ) ≤ g (C (j)).
77 / 369
Laufzeit Phase
In jeder Phase wird also ein minimaler s-t-Schnitt berechnet. Die
Laufzeitanalyse einer Phase ist identisch zum Prim-Algorithmus:
Wird der Rand R als ein Feld oder als eine Liste verwaltet, so ergibt
sich die Zeit n · O(n) + e · O(1) = O(n2 ).
Bei Verwendung eines Heaps erhalten wir
n · O(log n) + e · O(log n) = O(e log n).
Mit Fibonacci-Heaps ergibt die beste Abschätzung:
n · O(log n) + e · O(1) = O(e + n log n)
78 / 369
Gesamtlaufzeit
Nach jeder Phase wird der Graph durch Verschmelzen der beiden
Knoten s und t verkleinert. Dies ist eine O(n)-Operation. Das
Gewicht des jeweils aktuellen minimalen Schnittes ergibt sich in O(1)
durch einen direkten Gewichtsvergleich. Die Aktualisierung der
Partition (C1 , C2 ) kostet dann O(n) Schritte. Der Algorithmus
terminiert, wenn der Graph nur noch einen Punkt enthält, d. h., es
werden (n − 1) Phasen durchlaufen. Dies ergibt die Gesamtzeit O(n3 )
für Felder oder Listen, O(ne log n) für Heaps und O(ne + n2 log n) für
Fibonacci-Heaps.
79 / 369
Phase
Algorithmus 4.1
function Phase (G = (V , E , γ) || |V | ≥ 2; v1 ∈ V );
Die Ausgabe besteht aus zwei Knoten s, t mit dem Gewicht gphase
*)
var
B : Knotenmenge;
R : Knotenmenge;
s, t, v , w : V ;
begin
B := {v1 }; R := V \ {v1 };
forall v ∈ R do
g (v ) := γ(v1 v );
endfor
s := v1 ;
eines minimalen s-t-Schnittes.
(∗ Baumknoten ∗)
(∗ Randknoten ∗)
(∗ Initialisierungen ∗)
80 / 369
Berechnung eines minimalen Schnittes
Algorithmus 4.2 Fortsetzung
while |R| > 1 do
s := Knoten v ∈ R mit g (v ) ≥ g (w )∀w ∈ R;
R := R \ {s};
B := B ∪ {s};
forall sw ∈ E , w ∈ R do
g (w ) := g (w ) + γ(sw )
endfor
endwhile
t := der letzte Knoten in R
return (s, t, g (t))
endfunction
(∗ begin delete max ∗)
(∗ end delete max ∗)
(∗ increase key ∗)
81 / 369
Berechnung eines minimalen Schnittes
Algorithmus 4.3
function Min Cut( G = (V , E , γ), |V | ≥ 2)
(Partition C1 , C2 mit minimalem Schnitt g );
var
C1 , C2 : Knotenmenge;
(∗ Partition von V ∗)
s, t : V ; g , gphase : integer;
begin
wähle ein v1 ∈ V ; (s, t, gphase ) := Phase(G , v1 );
verschmelze s und t; der neue Graph sei G /(s = t);
if |V | = 2 then C1 := {s}; C2 := {t}; g := gphase ;
else (C1 , C2 , g ) := Min Cut (G /(s = t));
endif
(∗ Die Partition (C1 , C2 ) von G /(s = t) ist auch ein Schnitt von G . ∗)
82 / 369
Berechnung eines minimalen Schnittes
Algorithmus 4.4 Fortsetzung und Ende von Min Cut
if gphase ≤ g then
C1 := V \ {t};
C2 := {t};
g := gphase ;
endif
return (C1 , C2 , g )
endfunction
83 / 369
Beispiel: Berechnung eines minimalen Schnittes
2
1
3
2
5
3
2
2
3
6
2
1
4
3
4
2
7
2
3
8
Abbildung: Ein Graph G = (V , E ) mit Kantengewichten γ : E → N. Der
Startknoten ist Knoten 2.
84 / 369
Beispiel: Berechnung eines minimalen Schnittes
t
2
1
3
a
2
2
5
s
2
3
6
f
b
3
3
2
1
4
c
4
2
7
d
2
3
8
e
Abbildung: Der Graph nach der ersten Phase mit Startknoten 2. Die Knoten
wurden in der Reihenfolge a, b, c, d, e, f , s, t besucht. Der gefundene Schnitt
ist die Partition {1} , {2, 3, 4, 5, 6, 7, 8} mit Gewicht g = 5.
85 / 369
Beispiel: Berechnung eines minimalen Schnittes
a
2
4
1,5
b
2
3
6
c
d
3
3
2
1
4
c
4
2
7
s
2
3
8
t
Abbildung: Der Graph nach der zweiten Phase. Die Knoten wurden in der
Reihenfolge a, b, c, d, e, s, t besucht. Der gefundene Schnitt ist die Partition
{8} , {1, 2, 3, 4, 5, 6, 7} mit Gewicht g = 5.
86 / 369
Beispiel: Berechnung eines minimalen Schnittes
a
2
4
1,5
b
6
c
3
2
2
3
d
3
1
4
s
4
4
7,8
t
Abbildung: Nach der dritten Phase. Der gefundene Schnitt ist die Partition
{7, 8} , {1, 2, 3, 4, 5, 6} mit Gewicht g = 7.
87 / 369
Beispiel: Berechnung eines minimalen Schnittes
a
3
2
4
1,5
b
s
3
6
2
3
6
c
1
4,7,8
t
Abbildung: Nach der vierten Phase. Der gefundene Schnitt ist die Partition
{4, 7, 8} , {1, 2, 3, 5, 6} mit Gewicht g = 7.
88 / 369
Beispiel: Berechnung eines minimalen Schnittes
t
a
3
2
4
1,5
b
2
3
3,4,7,8
1
6
s
Abbildung: Nach der fünften Phase. Der gefundene Schnitt ist die Partition
{3, 4, 7, 8} , {1, 2, 5, 6} mit Gewicht g = 4.
89 / 369
Beispiel: Berechnung eines minimalen Schnittes
a
2
5
4
1,5
t
3
3,4,6,7,8
s
Abbildung: Nach der sechsten Phase. Der gefundene Schnitt ist die Partition
{1, 5} , {2, 3, 4, 6, 7, 8} mit Gewicht g = 7.
90 / 369
Beispiel: Berechnung eines minimalen Schnittes
s
2
9
V \2
t
Abbildung: Nach der siebten Phase. Der gefundene Schnitt ist die Partition
{2} , {1, 3, 4, 5, 6, 7, 8} mit Gewicht g = 9.
91 / 369
Übung: Wie verhält sich der Algorithmus bei negativen
Kantengewichten, bleibt er korrekt?
92 / 369
Antwort: siehe Übungen :-)
93 / 369
4. und 5. Vorlesung am 6. und 8.11.2012
Thema: Randomisierte Verfahren
1. Las Vegas (Quicksort) vs Monte Carlo (Primzahlerkennung,
Fermat-Test).
2. Monte Carlo für minimale Schnitte nach David Clifford Karger
und Stein:
A New Approach to the Minimum Cut Problem
Journal of the ACM (1996) 601-640.
94 / 369
Monte-Carlo- und Las-Vegas-Algorithmen
Monte-Carlo-Algorithmen sind randomisierte Algorithmen, die bei
beschränkter Laufzeit mit einer kleinen Wahrscheinlichkeit ein falsches
Ergebnis liefern dürfen.
Durch Wiederholen des Algorithmus kann die Fehlerwahrscheinlichkeit
gesenkt werden.
Im Gegensatz zu Monte-Carlo-Algorithmen dürfen
Las-Vegas-Algorithmen nur korrekte Lösungen berechnen, aber mit
einer geringen Wahrscheinlichkeit ist die Laufzeit lang.
Kann man die Richtigkeit eines Ergebnisses effizient überprüfen, so
kann man Monte-Carlo-Algorithmen in Las-Vegas-Algorithmen
überführen, indem man sie solange wiederholt, bis ein richtiges
Ergebnis gefunden wird.
95 / 369
Monte-Carlo Methode zur Berechnung minimaler Schnitte
1. Wähle eine Kante zufällig.
2. Kontrahiere.
3. Wiederhole.
Analyse: Zur Vereinfachung der Rechnung sei das Gewicht einer
Kante stets 1. (Wir erlauben Mehrfachkanten.)
Sei k das Gewicht des minimalen Schnitts, dann gilt:
k ≤ min { deg(v ) | v ∈ V } .
Die Anzahl (das Gewicht) aller Kanten ist |E | ≥ kn/2, aber die Zahl
der Schnittkanten ist ≤ k.
Wähle Kante e zufällig, dann wird nur mit W’keit ≤ 2k/(kn) = 2/n
eine Schnittkante getroffen.
Also ist die W’keit keine Schnittkante zu treffen ≥ 1 − 2/n =
Es ist also im Prinzip eine gute Idee, die gewählte Kante e zu
kontrahieren.
n−2
n .
96 / 369
Monte-Carlo-Ansatz
Wiederholen wir das Experiment c-mal, so haben wir immer noch die
W’keit keine Schnittkante zu treffen:
≥
n−2 n−3
n−c −1
(n − c)(n − c − 1)
·
···
=
.
n
n−1
n−c +1
n(n − 1)
Für c = n − 2 ist die Schranke für die W’keit allerdings ziemlich klein
geworden. Immerhin:
≥
2
.
n(n − 1)
97 / 369
Die maximale Anzahl minimaler Schnitte
Folgerung: Die Anzahl der minimalen Schnitte ist durch n2
begrenzt, denn jeder minimale Schnitt wird ja mit mindestens der
2
W’keit n(n−1)
gefunden.
98 / 369
Monte-Carlo Ansatz nach Karger
Wiederhole das Experiment z.B. n2 log n-mal und behalte das beste
Ergebnis. Dann ist die W’keit groß, einen fest gewählten minimalen
Schnitt zu finden.
Problem: Zu langsam! Die Kantenkontraktionen pro Experiment
kosten O(n2 ), also Laufzeitabschätzung > n4 .
99 / 369
Monte-Carlo-Ansatz nach Karger und Stein
Nächste Idee: Die Chancen, einen minimalen Schnitt zu treffen, sind
zu Anfang gering und nehmen dann zu.
Erfolg ist ab jetzt keine Schnittkante zu treffen. Misserfolg ist, eine
zu treffen (und daher nicht den gewünschten Schnitt zu finden).
Für c = n/2 ist die Erfolgs-W’keit noch mindestens
≥
(2n − n)(2n − n − 1)
= 1/4.
4n(n − 1)
√
Für n − c = n/ 2 ist die Erfolgs-W’keit mindestens
1/2.
Dies ist daher unser Cut-Off-Point.
100 / 369
Karger-Stein-Algorithmus
√
Sei G der Eingabegraph mit n Knoten, n = ( 2)k . (Wir
vernachlässigen bewusst Rundungsfehler und kleine n.)
Sei C ein fester minimaler Schnitt. Berechnung von C :
1.) Wiederhole das
√ Folgende zweimal:
2.) Wähle n − n/ 2-mal eine Zufallskante und kontrahiere jeweils die
entsprechende Kante.
◮
◮
◮
◮
Zeit für alle Kantenkontraktionen O(n2 ).
Wir behandeln nicht, wie man effizient zufällige Kanten wählt, die
ein Gewicht haben. (Die ist durchaus nicht trivial!)
W’keit, Schnitt C nicht
√ getroffen zu haben, ist ≥ 1/2.
Restgraph G ′ hat ( 2)k−1 Knoten.
Starte rekursiv den ganzen Algorithmus für G ′ .
3.) Behalte das bessere Ergebnis, also den kleineren Schnitt.
Laufzeit:
Mastertheorem I:
oder direkt:
√
t(n) = 2t(n/ 2) + O(n2 ).
t(n) ∈ O(n2 log n).
t(n) = 2n2 log n.
101 / 369
Erfolgswahrscheinlichkeit: Ω(1/log n)
Es sei pk die (Mindest-)Erfolgswahrscheinlichkeit.√Wir können pk = 1
für kleine Werte von k ansetzen. Betrachte n = ( 2)k+1 .
1. Schnitt C wird bei den initialen Kantenkontraktionen mit W’keit
1/2 nicht getroffen.
2. Erfolg beim rekursiven Aufruf auf G ′ ist ≥ pk .
3. Erfolg beim ersten Durchlauf insgesamt ≥ p2k ,
Misserfolg also ≤ 1 − p2k .
2
4. Misserfolg bei beiden Durchläufen auf G ist ≤ 1 − p2k .
5. Erfolg insgesamt bei G ist
pk 2
)
2
p2
= 1 − 1 + pk − k
4
pk2
= pk −
4
pk+1 ≥ 1 − (1 −
102 / 369
Lösung der Rekursion pk+1 ≥ pk − pk2 /4
Ansatz, definiere eine reelle Zahl zk ≥ 3 durch:
4
pk =
zk + 1
Also:
1
1
1
−
zk+1 + 1
zk + 1 (zk + 1)2
zk
=
(zk + 1)2
zk
= 2
zk + 2zk + 1
≥
Damit folgt für die Kehrbrüche:
zk2 + 2zk + 1
1
= zk + 2 +
zk
zk
1
≤ zk + 1 +
zk
zk+1 + 1 ≤
zk+1
103 / 369
Zack zack.
Wegen zk > 1 folgt
zk+1 ≤ zk + 1 +
1
< zk + 2
zk
Also wegen z2 = 3 mit Induktion zk ≤ 2k − 1 für k ≥ 2:
zk ≤ 2k − 1 ∈ O(k)
2
1
pk ≥ ∈ Ω( )
k
k
Wegen k = log√2 n = 2 log2 n folgt für die Erfolgswahrscheinlichkeit
P(n) des Karger-Stein-Algorithmus:
1
1
P(n) ≥
∈Ω
.
log2 n
log n
104 / 369
Finde minimale Schnitte mit hoher W’keit
Satz 4.2
Wiederholen wir den Karger-Stein-Algorithmus 3 · ln n · log2 n-mal, so
finden wir alle minimalen Schnitte in der Zeit O(n2 log3 n) mit einer
1
.
Fehlerwahrscheinlichkeit kleiner als 2n
Beweis: Sei C zunächst ein fester minimaler Schnitt:
3·ln n·log2 n
1
Pr(C wird nicht gefunden) ≤ 1 −
log2 n
≤e
Es gibt höchstens
n
2
−3·ln n·log2 n
log2 n
≤ e −3 ln n =
1
n3
minimale Schnitte. Also
n 1
1
<
Pr(Nicht alle gefunden) ≤
3
2 n
2n
105 / 369
6. Vorlesung, 13.11.2012
Entwurfstrategie:
Teile und Beherrsche – Divide and Conquer
Beispiele für Divide and Conquer:
◮ Quicksort
◮ Mergesort
◮ Multiplikation ganzer Zahlen (Karatsuba 1960)
◮ Matrixmultiplikation (Strassen 1969)
106 / 369
Multiplikation ganzer Zahlen
Schulmäßige Multiplikation von zwei Binärzahlen der Länge n
erfordert O(n2 ) Operationen.
Teile und Beherrsche:
r =
A
B
s =
C
D
Dabei sind A (C ) die ersten und B (D) die letzten k Bits von r (s).
r = A 2k + B;
s = C 2k + D
r s = A C 22k + (A D + B C ) 2k + B D
Mastertheorem I sagt tmult-ng (n) = 4 · tmult-ng (n/2) + O(n) ∈ O(n2 )
Nichts gewonnen!
107 / 369
Multiplikation ganzer Zahlen
Berechne stattdessen besser rekursiv AC , (A − B)(D − C ) und BD.
Aufwand: 3 · tmult (n/2) + O(n)
rs = A C 22k + (A − B) (D − C ) 2k + (B D + A C ) 2k + B D
Mastertheorem I sagt:
log 3
tmult (n) = 3 · tmult (n/2) + O(n) ∈ O(n log 2 ) = O(n1.58496... ).
Wir haben also durch den Teile-und-Beherrsche Ansatz den
Exponenten des naiven Ansatzes von 2 auf 1.58496... heruntergesetzt.
108 / 369
Schnelle Multiplikation
Nach einem Verfahren von Schönhage-Strassen (diskrete FFT in
geeigneten Restklassenringen) lassen sich zwei Binärzahlen in der Zeit
O(n log n log log n) multiplizieren.
2007: Der log log n-Term lässt sich nach Martin Fürer noch weiter
∗
verkleinern. Wissen heute O(n log n 2log n ) mit log∗ n ≤ 5 für alle
denkbaren“ Werte.
”
109 / 369
Matrixmultiplikation mittels Teile und Beherrsche“
”
Die übliche Multiplikation
zweier n × n Matrizen
P
(ai,j ) (bi,j ) = ( nk=1 ai,k bk,j ) erfordert O(n3 ) skalare Multiplikationen.
Divide-and-Conquer: A, B werden in 4 gleichgroße Untermatrizen
unterteilt, wobei sich das Produkt AB = C wie folgt darstellen lässt:
A12
B12
C12
A11
B11
C11
=
A22
B22
C22
A21
B21
C21
110 / 369
Matrixmultiplikation naiver Divide-and-Conquer
A11
A21
A12
A22
B11
B21
B12
B22
=
C11
C21
C12
C22
Dabei ergeben sich folgende Beziehungen:
C11 = A11 B11 + A12 B21
C12 = A11 B12 + A12 B22
C21 = A21 B11 + A22 B21
C22 = A21 B12 + A22 B22
Also:
t(n) ∈ 8 · t(n/2) + Θ(n2 ) ∈ Θ(n3 )
Keine Verbesserung gegenüber dem Standardverfahren!
111 / 369
Matrixmultiplikation nach Strassen
Berechne das Produkt von 2 × 2 Matrizen mit 7 Multiplikationen:
M1
:=
M2
:=
M3
:=
M4
:=
M5
:=
M6
:=
M7
:=
(A12 − A22 )(B21 + B22 )
C11
=
(A11 + A22 )(B11 + B22 )
C12
=
(A11 − A21 )(B11 + B12 )
C21
=
M6 + M7
C22
=
M2 − M3 + M5 − M 7
(A11 + A12 )B22
A11 (B12 − B22 )
M1 + M2 − M4 + M 6
M4 + M5
A22 (B21 − B11 )
(A21 + A22 )B11
Laufzeit: t(n) ∈ 7t(n/2) + Θ(n2 ).
Mastertheorem I mit a = 7, b = 2, c = 2 liefert:
t(n) ∈ Θ(nlog2 7 ) = Θ(n2,81... )
112 / 369
Bemerkungen zur Matrixmultiplikation
Die Strassen-Arbeit war 1969 ein theoretischer Durchbruch, da
erstmals die n3 -Schranke unterboten wurde.
Praktisch wird der Strassen-Algorithmus, wenn überhaupt, nur bei
sehr großen Matrizen eingesetzt.
Theoretisch liefert der Coppersmith–Winograd-Algorithmus eine
bessere Schranke.
Beste bekannte Schranke 2012: O(n2,3727 ).
113 / 369
7. Vorlesung, 15.11.2012
Entwurfstrategie:
Dynamisches Programmieren
Beispiele:
◮ Rucksack
◮ NFA 2 REG
◮ Warshall, Floyd
◮ Optimale Klammerung bei Matrizenprodukten
◮ CYK
◮ Optimale Suchbäume
Reduktion Matrixmultiplikation auf Transitive Hülle und
umgekehrt
114 / 369
Entwurfsstrategie: Dynamisches Programmieren
Beim Verfahren der dynamischen Programmierung werden tabellarisch
alle Teillösungen eines Problems bestimmt, bis schließlich die
Gesamtlösung erreicht ist. Die Teillösungen werden dabei mit Hilfe der
bereits existierenden Einträge berechnet.
115 / 369
Dynamisches Programmieren vs Backtracking
Dynamischen Programmieren ist eng verwandt mit der Problemlösung
durch Backtracking. Die zusätzliche Idee ist, Rekursion durch Iteration
zu ersetzen und durch tabellarisches Festhalten von Teillösungen
Mehrfachberechnungen zu vermeiden.
BEISPIEL: Erinnerung an die Theorie-Vorlesung: Satz von Kleene.
Bestimmung reguläre Ausdrücke:
NEA A = (Q, Σ, δ ⊆ Q × Σ × Q, I , F ),
Lk [i, j] = Sprache von i nach j über erlaubte Zwischenzustände aus
der Menge {1, . . . , k}.
L0 [i, j] = Kantenbeschriftung, (bzw. ε).
Gesucht Ln [i, j] für alle i ∈ I und j ∈ F .
Lk [i, j] := Lk−1 [i, j] + Lk−1 [i, k] · Lk−1 [k, k]∗ · Lk−1 [k, j]
116 / 369
Bestimmung reguläre Ausdrücke: Gesamtschrittalgorithmus
Algorithmus 6.1 Reguläre Ausdrücke aus einem endlichen Automaten
Eingabe : NEA A = (Q, Σ, δ ⊆ Q × Σ × Q, I , F )
procedure NEA2REGEXPGS
(Initialisiere: L[i, j] := {a | (i, a, j) ∈ δ ∨ a = ε ∧ i = j})
begin
for k := 1 to n do
for i := 1 to n do
for j := 1 to n do
Ltemp [i, j] := L[i, j] + L[i, k] · L[k, k]∗ · L[k, j]
endif
endfor
endfor
L := Ltemp
endfor
end
117 / 369
Bestimmung reguläre Ausdrücke: Einzelschrittalgorithmus
Algorithmus 6.2 Reguläre Ausdrücke aus einem endlichen Automaten
Eingabe : NEA A = (Q, Σ, δ ⊆ Q × Σ × Q, I , F )
procedure NEA2REGEXP
(Initialisiere: L[i, j] := {a | (i, a, j) ∈ δ ∨ a = ε ∧ i = j})
begin
for k := 1 to n do
for i := 1 to n do
for j := 1 to n do
L[i, j] := L[i, j] + L[i, k] · L[k, k]∗ · L[k, j]
endif
endfor
endfor
endfor
end
118 / 369
Vergleich der beiden Algorithmen
Vergleich der Algorithmen ausgeführt auf einem vollständigen
Automaten (von jedem Zustand zu jedem Zustand gibt es genau
einen Übergang).
n
1
2
3
4
5
6
7
8
9
10
11
12
13
Länge des entstehenden
regulären Ausdrucks beim
Gesamtschrittalgorithmus
16
52
200
784
3 104
12 352
49 280
196 864
786 944
3 146 752
12 584 960
50 335 744
201 334 784
Länge des entstehenden
regulären Ausdrucks beim
Einzelschrittalgorithmus
16
278
6 034
148 102
3 694 306
92 332 918
2 308 248 754
57 705 996 262
1 442 649 238 786
36 066 228 966 358
901 655 718 149 074
22 541 392 935 697 222
563 534 823 338 341 666
119 / 369
Wortproblem für kontext-freie Sprachen
Das Wortproblem für kontext-freie Sprachen lässt sich in der Zeit
O(n3 ) lösen: Stichwort CYK (siehe unten).
Eine Reduktion auf Multiplikation boolescher Matrizen liefert nach
Strassen:
O(nlog2 7 ).
120 / 369
CYK-Algorithmus
for i := 1 to N do
Var[i, i] := {A ∈ V | (A → ai ) ∈ P};
for j := i + 1 to N do
Var[i, j] := ∅;
endfor
Eingabe: w = a1 · · · aN
endfor
Var[i, j] := {A ∈ V | A ⇒∗ ai · · · aj }
for d := 1 to N − 1 do
(1 ≤ i ≤ j ≤ N)
for i := 1 to N − d do
j := i + d;
for k := i to j − 1 do
Var[i, j] := Var[i, j] ∪
{A ∈ V | (A → BC ) ∈ P, B ∈ Var[i, k], C ∈ Var[k + 1, j]}
endfor
endfor
endfor
return Var[1, N]
121 / 369
Transitive Hülle
Algorithmus 6.3 Warshall-Algorithmus: Berechnung transitiver Hülle
Eingabe : Graph als Adjazenzmatrix (A[i, j]) ∈ Booln×n
procedure Warshall (var A : Adjazenzmatrix)
begin
for k := 1 to n do
for i := 1 to n do
for j := 1 to n do
if (A[i, k] = 1) and (A[k, j] = 1) then
A[i, j] := 1
endif
endfor
endfor
endfor
end
122 / 369
Korrektheit: Warshall
Die Korrektheit des Warshall-Algorithmus folgt aus der Invarianten:
1. Nach dem k-ten Durchlauf der ersten for-Schleife gilt A[i, j] = 1,
falls ein Pfad von i nach j über Knoten mit Nummern ≤ k
existiert.
– Beachte, k steht ganz außen!
2. Gilt A[i, j] = 1, so existiert ein Pfad von i nach j.
123 / 369
Transitive Hülle?
Algorithmus 6.4 Ist dies Verfahren korrekt?
Eingabe : Graph als Adjazenzmatrix (A[i, j]) ∈ Booln×n
procedure Warshall’ (var A : Adjazenzmatrix)
begin
for i := 1 to n do
for j := 1 to n do
for k := 1 to n do
if (A[i, k] = 1) and (A[k, j] = 1) then
A[i, j] := 1
endif
endfor
endfor
endfor
end
124 / 369
Antwort
Antwort in den Übungen
125 / 369
Von Warshall zu Floyd
Trägt man in die Adjazenz-Matrix vom Warshall-Algorithmus
Kantengewichte statt Boolesche Werte ein, so entsteht der
Floyd-Algorithmus zur Berechnung kürzester Wege.
126 / 369
Floyd-Algorithmus
Algorithmus 6.5 Floyd: Alle kürzesten Wege in einem Graphen
Eingabe : Gewichteter Graph als Adjazenzmatrix A[i, j] ∈ (N ∪ ∞)n×n ,
wobei A[i, j] = ∞ bedeutet, dass es keine Kante von i nach j gibt.
procedure Floyd (var A : Adjazenzmatrix)
begin
for k := 1 to n do
for i := 1 to n do
for j := 1 to n do
A[i, j] := min{A[i, j], A[i, k] + A[k, j]};
endfor
endfor
endfor
endprocedure
127 / 369
Floyd-Algorithmus
Der Floyd-Algorithmus liefert ein korrektes Ergebnis auch wenn die
Gewichte negativ sind, unter der Bedingung, dass keine negative
Schleifen vorhanden sind.
Zeitaufwand von Warshall und Floyd ist Θ(n3 ). Verbesserung“
”
dadurch, dass vor der j-Schleife zuerst getestet wird, ob A[i, k] = 1
(bzw. ob A[i, k] < ∞) gilt.
Damit erreicht man den Aufwand O(n3 ):
128 / 369
Floyd-Algorithmus
Algorithmus 6.6 Floyd-Algorithmus in O(n3 )
Eingabe : Adjazenzmatrix A[i, j] ∈ (N ∪ ∞)n×n
procedure Floyd (var A : Adjazenzmatrix)
begin
for k := 1 to n do
for i := 1 to n do
if A[i, k] < ∞ then
for j := 1 to n do
A[i, j] := min{A[i, j], A[i, k] + A[k, j]};
endfor
endif
endfor
endfor
endprocedure
129 / 369
Floyd-Algorithmus
Algorithmus 6.7 Floyd-Algorithmus mit negativen Zyklen
Eingabe : Adjazenzmatrix A[i, j] ∈ (Z ∪ ∞ ∪ −∞)n×n
procedure Floyd (var A : Adjazenzmatrix)
begin
for k := 1 to n do for i := 1 to n do
if A[i, k] < ∞ then for j := 1 to n do
if A[k, j] < ∞ then
if A[k, k] < 0
then A[i, j] := −∞
else A[i, j] := min{A[i, j], A[i, k] + A[k, j]}
endif
endif
endfor endif endfor endfor
endprocedure
130 / 369
Transitive Hülle und Matrixmultiplikation
Sei A = (aij ) die Adjazenzmatrix eines gerichteten Graphen mit n
Knoten. Der Warshall-Algorithmus berechnet den reflexiven
transitiven Abschluss A∗ in O(n3 ) Schritten. Hierbei ist
X
A∗ =
Ak
mit A0 = In und ∨ als Addition boolescher Matrizen
k≥0
Mit Induktion ergibt sich, dass Ak (i, j) = 1 genau dann gilt, wenn es
von i P
nach j einen Weg der Länge k gibt. Klar ist auch
n−1 k
A∗ = k=0
A .
131 / 369
Transitive Hülle ≤ Matrixmultiplikation
Setze B = In + A. Dann gilt A∗ = B m für alle m ≥ n − 1. Also reicht
es, eine Matrix ⌈log2 (n − 1)⌉-mal zu quadrieren, um A∗ zu berechnen.
Sei M(n) der Aufwand, zwei boolesche n × n-Matrizen zu
multiplizieren, und sei T (n) der Aufwand, die reflexive transitive Hülle
zu berechnen. Dann gilt also:
T (n) ∈ O(M(n) · log n).
Hieraus folgt für alle ε > 0 nach Strassen
T (n) ∈ O(nε+log2 7 ).
132 / 369
Matrixmultiplikation ≤ Transitive Hülle
Die Beziehung M(n) ∈ O(T (n)) gilt unter der plausiblen Annahme
M(3n) ∈ O(M(n)). Denn seien A und B beliebige Matrizen, dann gilt:

∗ 

0 A 0
In A AB
 0 0 B  =  0 In B  .
0 0 0
0 0 In
Unter den (ebenfalls plausiblen) Annahmen M(n) ∈ Ω(n2 ) und
M(2n) ≥ (2 + ε)M(n) zeigen wir
T (n) ∈ O(M(n)).
Dies bedeutet: die Berechnung der transitiven Hülle ist bis auf
konstante Faktoren genauso aufwendig wie die Matrixmultiplikation.
133 / 369
Berechnung der Transitive Hülle
Eingabe: E ∈ Bool(n × n)
1. Teile E in vier Teilmatrizen A, B, C , D so, dass A und D quadratisch sind und jede Matrix ungefähr die Größe n/2 × n/2 hat:
A B
E=
.
C D
2. Berechne rekursiv D ∗ : Aufwand T (n/2).
3. Berechne F = A + BD ∗ C : Aufwand O(M(n/2)), da
M(n) ∈ Ω(n2 ).
4. Berechne rekursiv F ∗ : Aufwand T (n/2).
5. Setze
∗
E =
F∗
F ∗ BD ∗
∗
∗
∗
D CF D + D ∗ CF ∗ BD ∗
.
134 / 369
Berechnung der Transitive Hülle
Damit erhalten wir die Rekursionsgleichung
T (n) ≤ 2T (n/2) + c · M(n)
für ein c > 0.
Dies ergibt
i · M(n/2i )
2
k≥0
i
P
2
≤ c · k≥0 2+ε
· M(n)
T (n) ≤ c ·
P
(nach Mastertheorem)
(da M(n/2) ≤
1
2+ε M(n))
∈ O(M(n)).
135 / 369
Beispiel: Multiplikation einer Matrizenfolge
Multiplikation von links
(10 × 1)
(1 × 10)
(10 × 1)
(1 × 10)
(10 × 1)
136 / 369
Beispiel: Multiplikation einer Matrizenfolge
Multiplikation von links
(10 × 1)
(1 × 10)
(10 × 1)
(1 × 10)
(10 × 1)
(10 × 1)
(1 × 10)
(10 × 1)
100 Multiplikationen
(10 × 10)
137 / 369
Beispiel: Multiplikation einer Matrizenfolge
Multiplikation von links
(10 × 1)
(1 × 10)
(10 × 1)
(1 × 10)
(10 × 1)
(10 × 1)
(1 × 10)
(10 × 1)
(1 × 10)
(10 × 1)
100 Multiplikationen
(10 × 10)
100 Multiplikationen
(10 × 1)
138 / 369
Beispiel: Multiplikation einer Matrizenfolge
Multiplikation von links
(10 × 1)
(1 × 10)
(10 × 1)
(1 × 10)
(10 × 1)
(10 × 1)
(1 × 10)
(10 × 1)
(1 × 10)
(10 × 1)
100 Multiplikationen
(10 × 10)
100 Multiplikationen
(10 × 1)
100 Multiplikationen
(10 × 10)
(10 × 1)
139 / 369
Beispiel: Multiplikation einer Matrizenfolge
Multiplikation von links
(10 × 1)
(1 × 10)
(10 × 1)
(1 × 10)
(10 × 1)
(10 × 1)
(1 × 10)
(10 × 1)
(1 × 10)
(10 × 1)
100 Multiplikationen
(10 × 10)
100 Multiplikationen
(10 × 1)
100 Multiplikationen
(10 × 10)
100 Multiplikationen
(10 × 1)
(10 × 1)
140 / 369
Beispiel: Multiplikation einer Matrizenfolge
Multiplikation von links
Insgesamt: 400 Multiplikationen
141 / 369
Beispiel: Multiplikation einer Matrizenfolge
Multiplikation von rechts
(10 × 1)
(1 × 10)
(10 × 1)
(1 × 10)
(10 × 1)
142 / 369
Beispiel: Multiplikation einer Matrizenfolge
Multiplikation von rechts
(10 × 1)
(1 × 10)
(10 × 1)
(10 × 1)
(1 × 10)
(10 × 1)
(1 × 10)
10 Multiplikationen
(10 × 1)
(1 × 1)
143 / 369
Beispiel: Multiplikation einer Matrizenfolge
Multiplikation von rechts
(10 × 1)
(1 × 10)
(10 × 1)
(10 × 1)
(1 × 10)
(10 × 1)
(10 × 1)
(1 × 10)
(1 × 10)
10 Multiplikationen
10 Multiplikationen
(10 × 1)
(1 × 1)
(10 × 1)
144 / 369
Beispiel: Multiplikation einer Matrizenfolge
Multiplikation von rechts
(10 × 1)
(1 × 10)
(10 × 1)
(10 × 1)
(1 × 10)
(10 × 1)
(10 × 1)
(1 × 10)
10 Multiplikationen
(10 × 1)
(1 × 1)
10 Multiplikationen
10 Multiplikationen
(10 × 1)
(1 × 10)
(10 × 1)
(1 × 1)
145 / 369
Beispiel: Multiplikation einer Matrizenfolge
Multiplikation von rechts
(10 × 1)
(1 × 10)
(10 × 1)
(10 × 1)
(1 × 10)
(10 × 1)
(10 × 1)
(1 × 10)
10 Multiplikationen
(10 × 1)
(1 × 1)
10 Multiplikationen
(10 × 1)
10 Multiplikationen
(10 × 1)
(1 × 10)
(1 × 1)
10 Multiplikationen
(10 × 1)
146 / 369
Beispiel: Multiplikation einer Matrizenfolge
Multiplikation von rechts
Insgesamt: 40 Multiplikationen
147 / 369
Beispiel: Multiplikation einer Matrizenfolge
Multiplikation in optimaler Reihenfolge
(10 × 1)
(1 × 10)
(10 × 1)
(1 × 10)
(10 × 1)
148 / 369
Beispiel: Multiplikation einer Matrizenfolge
(10 × 1)
(1 × 10)
(10 × 1)
(10 × 1)
(1 × 10)
(10 × 1)
(1 × 10)
10 Multiplikationen
(10 × 1)
(1 × 1)
149 / 369
Beispiel: Multiplikation einer Matrizenfolge
(10 × 1)
(1 × 10)
(10 × 1)
(10 × 1)
(1 × 10)
(10 × 1)
10 Multiplikationen
(10 × 1)
(1 × 10)
10 Multiplikationen
(1 × 1)
(10 × 1)
(1 × 1)
(1 × 1)
150 / 369
Beispiel: Multiplikation einer Matrizenfolge
(10 × 1)
(1 × 10)
(10 × 1)
(10 × 1)
(1 × 10)
(10 × 1)
10 Multiplikationen
(10 × 1)
(10 × 1)
(1 × 10)
10 Multiplikationen
(1 × 1)
(10 × 1)
(1 × 1)
(1 × 1)
1 Multiplikation
(1 × 1)
151 / 369
Beispiel: Multiplikation einer Matrizenfolge
(10 × 1)
(1 × 10)
(10 × 1)
(10 × 1)
(1 × 10)
(10 × 1)
10 Multiplikationen
(10 × 1)
(10 × 1)
(1 × 10)
10 Multiplikationen
(1 × 1)
(10 × 1)
(1 × 1)
(1 × 1)
1 Multiplikation
(1 × 1)
10 Multiplikationen
(10 × 1)
152 / 369
Beispiel: Multiplikation einer Matrizenfolge
Insgesamt: 31 Multiplikationen
153 / 369
8. Vorlesung, 20.11.2012
I saw the man on the hill with the telescope.“
”
und was soll es bedeuten?
(((Ich sah den Mann) auf dem Berg) mit dem Fernrohr)
((Ich sah (den Mann auf dem Berg)) mit dem Fernrohr)
(((Ich sah den Mann) (auf dem Berg mit dem Fernrohr)
(Ich sah ((den Mann auf dem Berg) mit dem Fernrohr))
(Ich sah (den Mann (auf dem Berg mit dem Fernrohr)))
5 Klammerungen
154 / 369
Multiplikation einer Matrizenfolge
A(n,m) sei eine Matrix A mit n Zeilen und m Spalten.
Annahme: A(n,m) := B(n,q) · C(q,m) benötigt n · q · m skalare
Multiplikationen.
N
3
2
1
.
, . . . , M(n
, M(n
, M(n
Eingabe: Matrizenfolge M(n
2 ,n3 )
1 ,n2 )
0 ,n1 )
N−1 ,nN )
cost(M 1 , . . . , M N ) := minimale Zahl der skalaren Multiplikationen,
um das Produkt M[1, N] = M 1 · · · M N zu berechnen.
Dynamisches Programmierung liefert:
cost(M i , . . . , M j ) =
mink {cost(M i , . . . , M k ) + cost(M k+1 , . . . , M j ) + ni−1 · nk · nj }
155 / 369
Multiplikation einer Matrizenfolge
for i := 1 to N do
cost[i, i] := 0;
for j := i + 1 to N do
cost[i, j] := ∞;
endfor
endfor
for d := 1 to N − 1 do
for i := 1 to N − d do
j := i + d;
for k := i to j − 1 do
t := cost[i, k] + cost[k + 1, j]
+ n[i − 1] · n[k] · n[j];
if t < cost[i, j] then
cost[i, j] := t;
best[i, j] := k;
endif
endfor
endfor
endfor
return cost[1, N]
156 / 369
Die Multiplikation nach der best-Tabelle
cost[i, j], best[i, j] sind berechnet.
Was nun?
Wir benötigen nur noch die best[i, j]-Werte.
i
und berechne M[1, N] rekursiv:
Setze M[i, i] = M(n
i−1 ,ni )
M[i, j] = M[i, best[i, j]] · M[best[i, j] + 1, j].
157 / 369
Thema: Optimale Suchbäume
158 / 369
Optimale Suchbäume
Erzeugung von optimalen Suchbäumen:
Die direkte Methode Θ(n3 ).
Der Algorithmus von Donald E. Knuth hat einen Aufwand von Θ(n2 ).
(Teleskop-Summe)
Interessant ist hier, wie man durch eine genaue Analyse des Problems
den kubischen Algorithmus in einen quadratischen verwandeln kann.
Der Algorithmus ist nicht komplizierter, sondern der Gewinn liegt im
Auslassen überflüssiger Schritte.
159 / 369
Optimale Suchbäume
Sei ein linear geordnetes Feld gegeben mit v1 < v2 < · · · < vn .
Zugriffshäufigkeit auf Knoten v sei durch γ(v ) gegeben.
Der Wert γ(v ) kann sowohl die relativen als auch die absoluten
Häufigkeiten bezeichnen.
160 / 369
Optimale Suchbäume
Binärer Suchbaum: knotenbeschrifteter Baum
Für jeden Knoten v mit linkem Unterbaum L und u ∈ L gilt: u < v
(bzw. w ∈ R rechts und dann v < w ).
Jeder Knoten v hat ein Level ℓ(v ):
ℓ(v ) := 1+ Abstand des Knotens v zur Wurzel.
Das Auffinden eines Knotens auf Level ℓ erfordert ℓ Vergleiche.
Ziel:
Finde einen binären Suchbaum, der die gewichtete innere Pfadlänge
X
ℓ(v ) · γ(v )
P(B) :=
v ∈V
minimiert.
161 / 369
Optimale Suchbäume
Optimaler Suchbaum für 1, 2, 22 , 23 , 24 , 25 mittels Greedy-Strategie.
25
24
23
22
2
1
162 / 369
Optimale Suchbäume
Optimaler Suchbaum für 1,2,3,4,5,6,7.
5
3
2
7
4
6
1
Gewichtete innere Pfadlänge: 1 · 5 + 2 · 10 + 3 · 12 + 4 · 1 = 65
163 / 369
Optimale Suchbäume
Suchbaum für 1, 2, 3, 4, 5, 6, 7 nach Greedy-Strategie:
7
6
5
4
3
2
1
Gew. innere Pfadlänge:
7 + 12 + 15 + 16 + 12 + 15 + 12 + 7 = 86
164 / 369
Optimale Suchbäume
Die innere Pfadlänge bestimmt die durchschnittlichen Kosten einer
Sequenz von Find-Operationen.
Dynamische Programmierung möglich,
da die Unterbäume eines optimalen Baums auch optimal sind.
165 / 369
Optimale Suchbäume
Bezeichnungen:
◮
Knotenmenge = {1, . . . , n},
d.h. die Zahl i entspricht dem Knoten vi . Weiterhin wird ℓi
(bzw. γi ) eine andere Schreibweise für ℓ(i) (bzw. γ(i)) sein.
◮
Pi,j : gewichtete innere Pfadlänge eines optimalen Suchbaumes
der Knoten {i, . . . , j}.
◮
◮
◮
Ri,j : Wurzel eines optimalen Suchbaumes für {i, . . . , j}.
Später: ri,j kleinstmögliche Wurzel, Ri,j größtmögliche Wurzel.
P
Γi,j := jk=i γ(k): Gewicht der Knotenmenge {i, . . . , j}.
166 / 369
Optimale Suchbäume
Im dynamischen Ansatz sind nun Werte ri,j oder Ri,j gesucht, die
einen optimalen Suchbaum B mit Kosten Pi,j realisieren. Man geht
nun direkt vor und berechnet P(B) rekursiv (dabei bezeichnet BL
bzw. BR den linken, bzw. rechten Unterbaum der Wurzel von B):
P(B) := P(BL ) + P(BR ) + Γ(B)
Wir realisieren diesen Ansatz zunächst in einem kubischen
Algorithmus.
Hier nur die Idee:
Algorithmus: Berechnung eines optimalen Suchbaums
◮
◮
Pi,j = Γi,j + mink∈i...j {Pi,k−1 + Pk+1,j }
ri,j = k, für den minimalen Index Pi,k−1 + Pk+1,j das Minimum
annimmt.
167 / 369
Optimale Suchbäume
Das folgende Lemma ist trivial:
Lemma (Monotonie der Funktion P(B))
Sei B ′ ein optimaler Suchbaum für {1, . . . , n} und v ∈ {1, . . . , n}. Sei
B ein optimaler Suchbaum für {1, . . . , n} \ {v }. Dann gilt
P(B) ≤ P(B ′ ).
168 / 369
Optimale Suchbäume
Beweis: Sei L′ bzw. R ′ der linke bzw. rechte Unterbaum von v . Ist
R ′ = ∅, so betrachten wir nun den Baum B̂ := B ′ \{v } (d.h., L′
rutscht ein Level höher). B̂ ist wieder ein Suchbaum und es gilt
offensichtlich P(B̂) ≤ P(B).
Ist R ′ 6= ∅, so sei v ′ der kleinste Knoten in R ′ . Sei R ein optimaler
Baum der Knoten aus R ′ \{v ′ }. Wir definieren einen Baum B̂ durch
Ersetzen von v durch v ′ in B ′ und von R ′ durch R. Dabei ist B̂
wieder ein Suchbaum und es gilt:
P(B ′ ) − P(B̂) ≥ γ(v ) · l ′ (v ) − γ(v ′ ) · l ′ (v ) + γ(v ′ ) · l ′ (v ′ ),
wobei der letzte Summand eine untere Schranke ist für die Differenz
P(R ′ ) − P(R) (bezogen auf den gesamten Baum B ′ bzw. B̂). Daraus
ergibt sich P(B̂) ≤ P(B ′ ) und damit P(B) ≤ P(B ′ ) für einen
optimalen Baum, der die Knotenmenge ohne v realisiert.
169 / 369
Optimale Suchbäume
Die folgende Beobachtung (von Knuth) ist entscheidend.
Satz 6.1 (Monotonie der Wurzel)
Sei r [i, j] (bzw. R[i, j]) die kleinste (bzw. größte) Wurzel eines
optimalen Suchbaumes für die Knoten {i, . . . , j}. Dann gilt für n ≥ 2:
r [i, j − 1] ≤ r [i, j],
R[i, j − 1] ≤ R[i, j].
Die Anschauung ist klar.
Der Beweis ist sehr schwierig.
170 / 369
Optimale Suchbäume
Beweis: Es reicht für n > 2 zu zeigen:
r [1, n − 1] ≤ r [1, n],
R[1, n − 1] ≤ R[1, n].
Mit Induktion ist das Lemma für j − i ≤ n − 2 bereits bewiesen.
Lemma: Sei {1, . . . , n} die Knotenmenge.
Sei Bj ein optimaler Suchbaum mit minimalem Level j von Knoten n
(also n möglichst hoch). Sei j1 die Wurzel von Bj .
Sei Bi ein optimaler Suchbaum mit Wurzel i1 ≥ j1 .
Dann existiert ein optimaler Suchbaum B ′
mit Wurzel i1 und Knoten n auf Level j.
171 / 369
Optimale Suchbäume
Diese Verbindung der Eigenschaften minimales Level für n und große
Wurzel ist für den Beweis des Satzes von Nutzen.
Beweis des Lemmas: Wir betrachten die rechten Äste, wobei die
Knoten von Bi mit ik und die Knoten von Bj mit jk bezeichnet sind:
Beachte i1 ≥ j1 .
Bj : j 1
Bi :
j2
1
i1
i2
..
2
..
.
n
.
ij
j
n
i
172 / 369
Optimale Suchbäume
Bei festem i1 maximieren wir i2 , dann maximieren wir i3 usw. Der
neue Baum wird weiterhin mit Bi bezeichnet. Angenommen, in Bi und
Bj liegt der Knoten n auf gleichem Level j. Dann sind wir fertig.
Andernfalls können wir (zur Vereinheitlichung der Bezeichnung)
annehmen, dass der Knoten n in Bi auf Level i liegt und i > j gilt,
weil j minimal gewählt wurde.
Sei k maximal mit ik > jk . Dann gilt 1 ≤ k < j. Setze m = k + 1. Es
gilt {ik + 1, . . . , n} ( {jk + 1, . . . , n}, und mit Induktion und
Links-Rechts-Symmetrie des Satzes gilt
jm ≤ R[jk + 1, n] ≤ R[ik + 1, n] = im . Also folgt jm = im , da k
maximal gewählt wurde.
173 / 369
Optimale Suchbäume
Sei nun Ri der rechte Unterbaum in Bi , der im als Wurzel hat, und Rj
sei der rechte Unterbaum in Bj , der jm als Wurzel hat. Wegen im = jm
haben Ri und Rj dieselbe Knotenmenge und sind optimale
Suchbäume. Wir bilden einen Baum B ′ durch Ersetzen von Ri in Bi
durch Rj . Da P(Ri ) = P(Rj ) gilt, ergibt sich auch
P(B ′ ) = P(Bi ) = P(Bj ), d. h. B ′ ist optimal für {1, . . . , n}, hat i1 als
Wurzel und den Knoten n auf Level j.
174 / 369
Optimale Suchbäume
Angenommen i2 = j2 , also m = 2. Wir erhalten das folgende Bild.
Beachte i1 ≥ j1 .
Bi :
1
B ′ : i1
i1
i2 = j2
j2
i2
..
..
.
ij
.
n
n
2
j
i
175 / 369
Optimale Suchbäume
Symmetrie ergibt:
Lemma: Sei Bi ein optimaler Suchbaum für {1, . . . , n} mit
maximalem Level i von Knoten n. Sei i1 die Wurzel von Bi . Sei Bj ein
optimaler Suchbaum für {1, . . . , n} mit Wurzel j1 ≤ i1 . Dann existiert
ein optimaler Suchbaum B ′ für {1, . . . , n} mit Wurzel j1 und Knoten
n auf Level i.
176 / 369
Optimale Suchbäume
Es sei α das Gewicht des größten Knotens n, d.h. α := γn . Der Wert
α variiert zwischen 0 und ∞.
Mit rα (bzw. Rα ) bezeichnen wir die kleinste (bzw. größte) Wurzel
eines optimalen Suchbaums für die Knoten {1, . . . , n}.
Sei zunächst α = 0 und seien B ′ bzw. B ′′ optimale Suchbäume für die
Knoten {1, . . . n − 1} mit Wurzel r [1, n − 1] bzw. R[1, n − 1]. Nimmt
man jeweils den Knoten n als rechtesten hinzu, so erhält man
Suchbäume für {1, . . . n}, ohne die gewichtete innere Pfadlänge zu
erhöhen. Nach der Monotonie von P(B) sind diese Suchbäume
optimal. Es folgt:
r [1, n − 1] = r0 [1, n]
und
R[1, n − 1] ≤ R0 [1, n].
Man beachte, dass nicht r [1, n − 1] > r0 [1, n] gelten kann, sonst
würde man einfach den Knoten n entfernen.
Daher reicht es zu zeigen, dass rα und Rα monoton mit α steigen.
177 / 369
Optimale Suchbäume
Ab jetzt betrachten wir nur noch die Knotenmenge i ∈ {1, . . . , n}.
Bi sei ein optimaler Suchbaum unter der Nebenbedingung, dass der
Knoten n auf dem Level i liegt.
Dann gilt für eine gewisse Konstante c(i):
Pα (Bi ) = α · i + c(i).
Der Graph Pα (Bi ) ist eine Gerade mit Steigung i.
Aufgrund der Linearität erhalten wir das folgende (vertikal gestauchte)
Bild, bei der jede Steigung i = 1, . . . , n höchstens einmal vorkommt.
178 / 369
Optimale Suchbäume
Pα
✻
Pα (Bn )
Pα (Bℓ )
Pα (Bi )
Pα (Bk )
Pα (Bj )
✲
α0
α
179 / 369
Optimale Suchbäume
Wenn wir α vergrößern, sind wir am Punkt α0 gezwungen, das Level
von n zu verkleinern.
Bei einem Knick, besteht die Chance Rα0 > Rα0 −ε .
Wähle bei α0 einen optimalen Suchbaum Bi mit Rα0 als Wurzel und
wähle einen bei α0 optimalen Suchbaum Bj mit minimalem Level j.
Erinnerung:Die Verbindung der Eigenschaften minimales Level für n
und große Wurzel ist von Nutzen.
Wegen des ersten Lemmas gibt es einen optimalen Suchbaum bei α0
mit Rα0 als Wurzel und Knoten n auf Level j. Dieser Suchbaum ist
optimal bis einschließlich zum nächsten Knick“. Erst dort könnte Rα
”
echt größer werden. Folglich steigt Rα monoton.
180 / 369
Optimale Suchbäume
Wir fahren jetzt von rechts nach links und starten bei α = ∞.
Die Monotonie heißt jetzt, rα muss von rechts nach links fallen
Wenn wir α verkleinern, sind wir am Punkt α0 gezwungen, das Level
des Knotens n auf einen größeren Wert zu ändern.
Wähle bei α0 einen optimalen Suchbaum Bj mit rα0 als Wurzel und
einen ebenfalls bei α0 optimalen Suchbaum Bi mit maximalem Level
i. Wegen des zweiten Lemmas gibt es einen optimalen Suchbaum bei
α0 mit rα0 als Wurzel und Knoten n auf Level i. Dieser Suchbaum ist
optimal bis einschließlich zum nächsten Knick“ nach links . Erst dort
”
könnte rα echt kleiner werden.
Folglich steigt rα von links nach rechts.
Damit ist das Monotonie Lemma gezeigt!
181 / 369
Optimale Suchbäume
cost[n, n + 1] := 0;
for i := 1 to n do
cost[i, i − 1] := 0;
cost[i, i] := γ(i);
Γ[i, i] := γ(i);
r[i, i] := i;
endfor
for d := 1 to n − 1 do
for i := 1 to n − d do
j := i + d;
t := ∞;
for k := r [i, j − 1] to r [i + 1, j] do
if cost[i, k − 1] + cost[k + 1, j] < t then
t := cost[i, k − 1] + cost[k + 1, j];
root := k;
endif
endfor
Γ[i, j] := Γ[i, j − 1] + γ(j);
cost[i, j] := t + Γ[i, j];
r [i, j] := root;
endfor
endfor
182 / 369
Optimale Suchbäume
Laufzeit:
n−1 n−d
X
X
d=1 i=1
n−1
X
(1 + r [i + 1, i + d] − r [i, i + d − 1]) =
3
(n − d + r [n − d + 1, n] − r [1, d]) ≤ n2 ∈ Θ(n2 ).
2
d=1
Bemerkung 6.2
◮
Ein linear geordnetes Feld v1 , . . . , vn kann aus einem
ungeordneten Feld in O(n log n) Schritten erzeugt werden. Dies
fällt aber bei Θ(n2 ) nicht ins Gewicht.
Damit gilt: aus einem beliebigen Feld mit n Elementen kann ein
optimaler Suchbaum in Θ(n2 ) Schritten erzeugt werden.
◮
Der Algorithmus von Knuth wird in vielen Lehrbüchern nur ohne
Beweis erwähnt.
183 / 369
9. Vorlesung, 22.11.2012
Mittlere Höhe binärer Suchbäume
Zunächst eine Wiederholung
184 / 369
Bezeichnungen
◮
◮
◮
π: Permutation von {1, . . . , n}
Schreibe π als Folge (π(1), π(2), π(3), . . . , π(n))
BI (π), I ⊆ {1, . . . , n}: Suchbaum mit den Elementen i ∈ I ,
eingefügt in der Reihenfolge (links nach rechts) von π.
(i ∈ I wird vor j ∈ I eingefügt, wenn π −1 (i) < π −1 (j) gilt.)
◮
Zufallsvariablen:
Wurzel von B(π) ist i.“ ∈ {0, 1}
”
XI (π) = Höhe von BI (π).“
”
YI (π) = 2XI (π) (Dies ist der Trick!)
Ri (π) =
185 / 369
Erwartungswerte
XI (π) =
Höhe von BI (π).“
”X (π)
YI (π) = 2 I
Ziel: E [Xn ] ∈ O(log n).
(unter der Annahme einer Gleichverteilung der Permutationen.)
Wir zeigen zunächst (denn dies ist einfacher!):
E [Yn ] ∈ O(n3 ).
186 / 369
Berechnung von E [Yn ]
n = 1: E [Y1 ] = 1.
n ≥ 2:
E [Yn ] = 2
n
X
i=1
E [Ri · max{Y{1,...,i−1} , Y{i+1,...,n} }]
P
Denn Yn (π) = 2 ni=1 (Ri (π) · max{Y{1,...,i−1} (π), Y{i+1,...,n} (π)}).
Man beachte, dass Ri (π) = 1, falls π(1) = i ist, und Ri (π) = 0
andernfalls.
187 / 369
Berechnung von E [Yn ]
Für i 6∈ I sind die Zufallsvariablen YI und Ri unabhängig. Also gilt:
E [Yn ] = 2
n
X
i=1
Es gilt E [Ri ] =
1
n
E [Ri ] · E [max{Y{1,...,i−1} , Y{i+1,...,n} }]
und max{YI , YJ }(π) ≤ YI (π) + YJ (π). Also:
n
2X
(E [Y{1,...,i−1} ] + E [Y{i+1,...,n} ]).
E [Yn ] ≤
n
i=1
Aufgrund der Linearität der Erwartungswerte und der Eigenschaft
E [YI ] = E [Y{1,...,|I |} ] = E [Y|I | ] gilt:
n
E [Yn ] ≤
2X
(E [Yi−1 ] + E [Yn−i ])
n
i=1
188 / 369
Berechnung von E [Yn ]
Aus
n
E [Yn ] ≤
erhalten wir
E [Yn ] ≤
2X
(E [Yi−1 ] + E [Yn−i ])
n
i=1
n
n−1
n−1
i=1
i=0
i=1
4X
4X
4X
E [Yi−1 ] =
E [Yi ] =
E [Yi ].
n
n
n
Da jeder Term in der Summe oben rechts zweimal gezählt wird
und ein leerer Baum nicht betrachtet werden muss.
189 / 369
Berechnung von E [Yn ]
Wir werden jetzt zeigen, dass E [Yn ] ≤
n = 1: E [Y1 ] = 1 =
1
4
n ≥ 2:
n−1
E [Yn ] ≤
=
4
3 .
4X
E [Yi ]
n
Induktion
i=1
1
·
n
n+3
4
1
4
≤
=
n+3
3
4X1
n
4
n+3
3
.
n−1
i=1
1
·
4
gilt.
i +3
3
n−1 1X
<
n
i=0
i +3
3
190 / 369
Berechnung von E [Xn ]
Ableitung von E [Xn ] aus E [Yn ]:
Sei X : Ω → R eine diskrete Zufallsvariable. Dann berechnet sich der
Erwartungswert durch
X
X
E [X ] =
Prob(i) · X (i) =
λi xi mit xi = X (i), λi = Prob(i).
i
i
Für eine konvexe Funktion f folgt dann aus der Jensen’schen
Ungleichung:
X
f (E [X ]) ≤
λi f (xi ) = E [f (X )].
i
191 / 369
Berechnung von E [Xn ]
Jensen’sche Ungleichung:
f (E [X ]) ≤ E [f (X )].
In unserem Fall ist die konvexe Funktion f (x) = 2x :
(n + 3)(n + 2)(n + 1)
24n3
1 n+3
=
≤
.
2E [Xn ] ≤ E [2Xn ] = E [Yn ] ≤
3
4
24
24
Also E [Xn ] ≤ 3 log2 n ∈ O(log n).
192 / 369
Jensen’sche Ungleichung
Sei
Pk f : R → R eine konvexe Funktion und λi ≥ 0 für 1 ≤ i ≤ k mit
i=1 λi = 1. Dann gilt
f
k
X
i=1
λ i xi
!
≤
k
X
λi f (xi ).
i=1
Beweis: Durch Induktion nach k.
k = 1: Dann ist λ1 = 1 und die Aussage trivial.
193 / 369
Jensen’sche Ungleichung
Schaubild der konvexen Funktion f :
λf (x) + (1 − λ)f (y )
x
λx + (1 − λ)y
y
Es gilt also für alle x < y und alle 0 ≤ λ ≤ 1:
f (λx + (1 − λ)y ) ≤ λf (x) + (1 − λ)f (y ).
194 / 369
10.-14. Vorlesung, {27, 29}.11.2012 sowie {06, 11, 13}.12.2012
Behandelte Themen:
◮
Backtracking: Geographie und Mautproblem.
◮
Berechnen maximaler Flüsse (bzw. minimaler Flüsse) nach Dinitz.
◮
Median (bzw. select) in Linearzeit.
◮
Durchschnittsanalyse von Quicksort und Quickselect.
195 / 369
Geographie: Ein Spiel mit Städten
Das Szenario ist das Zwei-oder Mehrpersonenspiel Geographie. Es
spielt z.B. eine Schulklasse gegen“ ihren Lehrer.
”
Vorgegeben eine Menge von Städten, z.B. die europäischen
Hauptstädte.
1. Eine Partei beginnt mit Nennung einer Hauptstadt.
2. Dann wird in Runden gespielt.
3. Endet ein genannter Hauptstadtname auf den Buchstaben A“,
”
so muss die andere Partei eine noch nicht genannte Hauptstadt
nennen, die mit A“ beginnt.
”
4. Gelingt es nicht, so hat die Partei verloren.
196 / 369
Hauptstädte Europas
Reykjavik
Oslo
Stockholm
Helsinki
Tallinn
Moskau
Riga
Kopenhagen
Dublin
Wilna
Minsk
London
Amsterdam
Berlin
Warschau
Kiew
Brüssel
Prag
Luxemburg
Paris
Bern
Bratislava
Wien
Vaduz
Budapest
Ljubljana
Zagreb
Andorra
Madrid
Monaco San Marino
Rom
Sarajevo
Chisinau
Belgrad Bukarest
Sofia
Podgorica
Skopje
Lissabon
Ankara
Tirana
Athen
Nikosia
Valetta
197 / 369
Polynomialzeitlösung bei festem Alphabet
Eingabe: n ≥ 1 Städte über einem Alphabet mit k Buchstaben wobei
k konstant sei, etwa k = 26.
Codiere die Eingabe als k × k-Matrix, wobei k konstant sei, etwa
k = 26.
Dann hat diejenige Person, die beginnt, eine Gewinnstrategie; und
diese ist in Polynomialzeit mittels dynamisches Programmieren
berechenbar.
Denn: Es gibt genau
codieren.
n+k 2
k2
verschiedene Matrizen, die m ≤ n Städte
198 / 369
Das Millionenspiel
A
B
C
D
E
F
G
H
I
J
K
L
M
N
O
P
Q
R
S
T
U
V
W
X
Y
Z
A
6
5
4
3
0
2
3
3
0
1
4
5
3
1
2
4
0
0
7
1
1
2
0
0
1
0
B
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
C
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
D
3
2
0
0
0
2
1
2
0
0
0
0
3
1
0
1
0
1
0
0
0
0
1
0
0
0
E
1
3
0
0
0
0
0
1
1
0
1
1
1
0
0
3
0
1
1
1
0
0
0
0
1
0
F
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
G
0
1
2
0
0
0
2
2
0
2
2
1
0
2
0
4
0
1
4
2
0
0
0
1
0
0
H
0
0
0
0
0
0
1
0
0
0
1
0
1
0
0
2
0
0
0
1
0
0
0
0
0
0
I
1
1
2
2
0
0
0
2
0
0
4
1
2
1
0
0
0
1
2
0
1
1
1
0
0
0
J
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
K
0
1
0
2
0
0
0
0
0
0
0
0
1
3
1
0
0
0
0
1
0
0
0
0
0
0
L
0
1
0
0
0
0
1
0
1
0
1
0
2
2
0
0
0
0
1
0
0
0
0
0
0
0
M
0
2
0
1
0
0
0
0
0
0
1
0
0
0
0
0
1
1
1
0
0
1
0
0
0
0
N
3
2
2
3
1
1
0
4
3
2
1
2
4
0
1
0
0
2
2
4
0
0
2
1
0
0
O
2
1
1
0
0
0
0
0
0
0
3
0
3
0
0
0
1
0
6
3
0
0
0
0
0
0
P
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
Q
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
R
2
0
0
1
0
0
0
0
1
2
2
0
1
1
1
1
0
0
1
0
1
1
0
0
0
0
S
0
1
2
2
1
0
1
0
0
0
0
2
1
0
0
1
0
0
0
3
0
0
0
0
0
0
T
0
4
0
0
0
0
0
1
0
0
1
0
1
1
0
1
0
2
1
1
0
0
0
0
0
0
U
0
3
1
1
0
1
2
1
0
0
0
2
2
0
1
0
0
0
2
0
0
0
1
1
0
1
V
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
W
0
0
1
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
X
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
Y
1
0
1
1
0
0
0
0
0
0
0
0
2
0
0
0
1
0
1
0
0
0
0
0
0
0
Z
0
0
1
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
Abbildung: Spielmatrix für das Millionenspiel mit 305 Städten
199 / 369
Versuch und Irrtum
Bei 305 Städten würde der Ansatz über das dynamische
Programmieren hoffnungslos versagen.
Potentiell sind größenordnungsmäßig bis zu 305676 = 30526×26
Matrizen zu berechnen.
Lösung: Tricks und Backtracking!
200 / 369
Backtracking
Sucht man in einem Baum, so ist zum Beispiel Tiefensuche ein
effizientes Verfahren, wenn sich frühzeitig entscheidet, ob in einem
Teilbaum eine Lösung zu finden ist oder nicht.
Backtracking (dt. Zurückgehen“) beschreibt ein solches Verfahren,
”
bei dem man im Berechnungsgraphen eines Problems solange
vorwärts geht, bis ein Knoten erreicht wird, der eine Lösung darstellt
oder bei dem sicher davon ausgegangen werden kann, dass von diesem
Knoten aus keine Lösung mehr zu finden ist. Ist dies der Fall, dann
geht man den Pfad einen Schritt zurück und entscheidet sich für einen
anderen Folgepfad u.s.w..
Backtracking findet Anwendung bei Problemen bei denen man auf
schlanke Suchbäume hofft. Wir betrachten nach dem Spiel der
Geographie jetzt das sogenannte Mautstraßenproblem
(engl. Turnpike-Problem).
201 / 369
Mautproblem
Beispiel 8.1
Fährt man in Frankreich über die Autobahn nach Paris, so muss Maut
gezahlt werden. Man bekommt hierzu eine Karte, die eine Tabelle mit
den Entfernungen und Gebühren zwischen den Ein- und Ausfahrten
enthält.
Die Frage ist nun: lässt sich die Lage der Ausfahrten aus den
Entfernungen rekonstruieren, wenn nur eine geordnete Liste der
Entfernungen mit ihren Vielfachheiten vorliegt?
Wir suchen also eine Lösung für folgendes Problem:
Es seien 0 = x0 < x1 < · · · < xn positive Zahlenwerte und A eine
n × n-Matrix mit Ai,j = |xi − xj |. Weiterhin sei D ein Feld, das die
Werte Ai,j , 1 ≤ i < j ≤ n, in sortierter Reihenfolge enthält. Gesucht
sind die Werte xk für 1 ≤ k ≤ n, wenn D gegeben ist.
202 / 369
Mautproblem
Bemerkung 8.2
1. Sind die Werte xk bekannt, dann kann A (bzw. D) in O(n2 )
(bzw. in O(n2 log n)) Schritten berechnet werden.
2. Sei D bekannt. Ist die Folge x0 , . . . , xn eindeutig bestimmt, falls
sie existiert? Wie komplex ist dann die Rekonstruktion?
Die erste Frage kann mit Nein beantwortet werden. Selbst dann
existiert keine eindeutige Lösung, wenn in D alle Einträge verschieden
sind (bis jetzt wurde aber kein Beispiel für n > 6 gefunden).
203 / 369
Mautproblem (Prozedur maut)
procedure maut(var X : XFeld; var D: DFeld; n: integer; var found: boolean);
begin
found := false;
X0 := 0;
(* Initialisierung linker und rechter Rand *)
Xn := max(D);
D := D − max(D);
(* D aktualisieren *)
X1 := Xn − max(D);
(* X1 kann wegen Symm. so gewählt werden *)
if (X1 − X0 ) ∈ D then
D := D − {|X1 − X0 |, |Xn − X1 |};
place(X , D, n, 1, n, found)
endif
endprocedure
204 / 369
Mautproblem (Prozedur place)
if D = ∅ then
found := true
else
d := max(D);
(* probiere Xl+1 := Xn − d *)
D ′ := {|Xj − (Xn − d)| | j ∈ {0, . . . , l} ∪ {r , . . . , n}};
if D ′ ⊆ D then
Xl+1 := Xn − d;
D := D − D ′ ;
(* D aktualisieren *)
place(X , D, n, l + 1, r , found);
(* rekursiv Lösung suchen *)
if found = false then
(* falls Misserfolg: Backtracking *)
D := D + D ′
(* D wiederherstellen *)
endif
endif
(* probiere Xr −1 := d *)
D ′ := {|Xj − d| | j ∈ {0, . . . , l} ∪ {r , . . . , n}};
if (found = false) and D ′ ⊆ D then
Xr −1 := d;
D := D − D ′ ;
(* D aktualisieren *)
place(X , D, n, l, r − 1, found);
(* rekursiv Lösung suchen *)
if found = false then
(* falls Misserfolg: Backtracking *)
D := D + D ′
(* D wiederherstellen *)
endif
endif
endif
205 / 369
Mautproblem: Komplexität
Zeitanalyse zum maut-Algorithmus: Die Datenstruktur für D sollte die
Operationen max(D), member, delete, insert effizient erlauben d.h. in
O(log(n)) (= O(log(n2 ))) Schritten. Dies wird etwa durch eine
geordnete Liste ermöglicht, bei der die delete-Funktion nur die Plätze
markiert, die insert-Funktion (wir fügen nur Werte ein, die wir vorher
gelöscht haben) hebt die Markierung von delete wieder auf. Member
ist einfach eine binäre Suche, und max(D) ist der Wert des Feldes mit
dem höchsten nicht-markierten Index. Alternativ ginge z.B. auch ein
AVL-Baum.
Der worst-case ist exponentiell und tritt dann ein, wenn sehr viel
zurückgesetzt werden muss. Beispiele hierfür sind bekannt, es zeigt
sich aber (empirisch), dass dieser Fall selten auftritt.
206 / 369
Flüsse
Definition 9.1
Ein Flussnetzwerk (V , c, s, t) besteht aus einer endlichen
Knotenmenge V , einem Startknoten s ∈ V (source) und einem
Zielknoten t ∈ V (target) sowie einer Kapazitätsfunktion
c : V × V → R≥0 .
Ein Flussnetzwerk ist also ein gewichteter gerichteter Graph, wobei
wir nur die Kanten mit positiver Kapazität zeichnen.
Definition 9.2
Ein Fluss ist eine Abbildung f : V × V → R, die den drei folgenden
Bedingungen genügt:
◮
◮
◮
(Schiefsymmetrie) Für alle x, y ∈ V gilt f (x, y ) = −f (y , x).
(Flusserhaltung)
Für alle u ∈ V mit s 6= u 6= t gilt
P
f
(u,
v
)
=
0.
v ∈V
(Kapazitätsbedingung) Für alle x, y ∈ V gilt f (x, y ) ≤ c(y , x).
207 / 369
Flüsse
Wir können uns jede Kante (x, y ) als ein Rohr- oder Leitungsstück
mit der Kapazität c(x, y ) vorstellen. Die Schiefsymmetrie können wir
uns so vorstellen, dass ein positiver Fluss von x nach y das Gleiche ist
wie ein negativer Fluss von y nach x.
Die Flusserhaltung besagt, dass bei inneren Knoten genau so viel
hineinfließt, wie auch wieder heraus kommt. Bei der Quelle und dem
Ziel ist es etwas anderes.
Definition 9.3
Der Wert kf k eines Flusses f : V × V → R an der Quelle ist definiert
durch
X
f (s, y )
kf k =
y ∈V
208 / 369
Flüsse und Schnitte
Definition 9.4
Ein Schnitt C = (A, B) ist eine Partition: V = A ∪˙ B mit A 6= ∅ =
6 B
und A ∩ B = ∅ .
Ein s-t-Schnitt ist ein Schnitt (A, B) mit s ∈ A und t ∈ B.
Als Kapazität c(A, B) eines st-Schnitts (A, B) bezeichnen wir
X
c(x, y ).
c(A, B) =
x∈A,y ∈B
Lemma 9.5
Sei f : V × V → R ein Fluss und (A, B) ein st-Schnitt. Dann gilt
X
f (x, y )
kf k =
Insbesondere gilt kf k =
P
x∈A,y ∈B
y ∈V
f (s, y ) =
P
x∈V
f (x, t).
209 / 369
Beweis
Beweis: Wir zeigen die Aussage mit Induktion nach |A|. Für A = { s }
ist die Aussage trivial.
Sei jetzt A = A′ ∪ { u } mit s ∈ A′ und u ∈
/ A′ .
P
′
Dann ist kf k = x∈A′ ,y ∈B ′ f (x, y ) für B = B ∪ { u } mit Induktion,
da |A|′ = |A| − 1. Es gilt
X
X
X
X
f (x, u)
f (u, y ) −
f (x, y ) +
f (x, y ) =
x∈A′ ,y ∈B ′
x∈A,y ∈B
y ∈B
x∈A
Nun ist s 6= u 6= t und daher liefert uns die Schiefsymmetrie
zusammen mit der Flusserhaltung die Behauptung wegen
X
X
X
X
X
f (u, v ) = 0
f (u, x) =
f (u, y ) +
f (x, u) =
f (u, y ) −
y ∈B
x∈A
Die Aussage kf k =
P
y ∈B
x∈V \{ t } f (x, t)
x∈A
v ∈V
ist der Spezialfall mit B = { t }.
210 / 369
Theorem von Ford und Fulkerson
Für alle st-Schnitte (A, B) und alle Flüsse f gilt
kf k ≤ c(A, B)
(1)
Der Satz von Ford und Fulkerson stellt fest, dass diese Grenze scharf
ist:
Satz 9.6 (Max-Flow-Min-Cut-Theorem)
Sei N = (V , c, s, t) ein Flussnetzwerk. Der maximale Wert kf k eines
st-Flusses f ist gleich der minimalen Kapazität c(A, B) eines
st-Schnitts (A, B). Sind ferner alle Kapazitäten natürliche Zahlen, so
kann der maximale Fluss f ganzahlig gewählt werden.
211 / 369
Residualgraph
Definition 9.7
Sei f ein beliebiger Fluss. Der Residualgraph zu f ist der induzierte
gerichtete Graph (V , Rf ) mit Kantenmenge
Rf = { (x, y ) ∈ V × V | c(x, y ) > f (x, y ) } .
Sei A ⊆ V die Menge der im Residualgraphen von s aus erreichbaren
Knoten. Setzen wir B = V \ A, so gilt
X
c(x, y ) − f (x, y ) = 0
x∈A,y ∈B
Ist t ∈
/ A, so definiert (A, B) mit B = V \ A einen st-Schnitt mit
kf k = c(A, B). Für t ∈ A können wir den Wert des Flusses entlang
eines Pfades von s nach t im Residualgraphen erhöhen, d.h. der Fluss
war nicht maximal.
212 / 369
Der Algorithmus von Dinitz
Der Algorithmus von Dinitz (engl. Dinic’s algorithm) startet mit dem
Nullfluss und arbeitet in Phasen. Vor jeder Phase ist bereits ein Fluss
f berechnet. Ist f noch kein maximaler Fluss, so werden innerhalb
einer Phase verschiedene Verbesserungspfade gefunden, bis der
Abstand von s zu t im Residualgraphen größer geworden ist. Innerhalb
jeder Phase wird spätestens in jedem n-ten Schritt eine von maximal
m Kanten gelöscht; damit terminiert eine Phase nach O(mn)
Schritten. Am Ende der Phase hat der Fluss einen echt größeren Wert.
Der entscheidende Punkt ist allerdings, dass höchstens n Phasen
ausgeführt werden, denn nach jeder Phase wird sich der Abstand von
s zu t im Residualgraphen um mindestens eins erhöht haben. Dieses
Argument liefert schließlich die Laufzeitschranke O(mn2 ).
213 / 369
Der Algorithmus von Dinitz
Wir haben bereits einen Fluss f vorliegen und beschreiben nun den
Ablauf einer Phase. Sei (V , Rf ) der Residualgraph von f . Aus
(x, y ) ∈ Rf folgt über die Schiefsymmetrie, dass c(x, y ) + c(y , x) > 0
gilt. Also hat Rf für jeden möglichen Fluss höchstens m Kanten. Die
Länge eines kürzesten Pfades von x nach y im aktuellen
Residualgraphen bezeichnen wir mit df (x, y ). Wir setzen
df (x, y ) = ∞, falls es keinen Pfad gibt. Der Wert df (x, y ) ist die
aktuelle Distanz von x nach y und hängt von f ab.
214 / 369
Der Algorithmus von Dinitz
Am Anfang einer Phase konstruieren wir den Levelgraphen. In den
Levelgraphen werden gewisse Knoten und Kanten von (V , Rf )
aufgenommen. Für d ≥ 0 setzen wir
Ld = { x ∈ V | df (s, x) = d }
und für d ≥ 1 setzen wir:
Ed = { (x, y ) ∈ Ld−1 × Ld | (x, y ) ∈ Rf }
S
Der Levelgraph
(L, E ) ist gegeben durch L = d≥0 Ld und
S
E = d≥1 Ed . Mit einer Breitensuche können wir (L, E ) in O(m)
Schritten berechnen. Innerhalb einer Phase ändern sich die
Knotenmengen Ld nicht. Insbesondere entfernen wir keine Knoten aus
L, lediglich Kanten aus E werden gestrichen. Der Residualgraph wird
im weiteren Verlauf der Phase zu keinem Zeitpunkt mehr explizit
berechnet.
215 / 369
Der Algorithmus von Dinitz
Befindet sich t nicht in L, so ist (L, V \ L) ein st-Schnitt mit Wert
kf k = c(L, V \ L). Nach 1 ist kf k maximal, und wir sind fertig. Im
Folgenden sei daher t ∈ L und k = df (s, t) zu Beginn der Phase.
Damit liegt t in Lk . Wir entfernen nun Kanten aus dem Levelgraphen,
solange es noch von s ausgehende Kanten gibt. Dies bedeutet, wir
werden (L, E ) dynamisch verändern und Flüsse augmentieren. Hierfür
definieren wir drei Invarianten, die für alle in dieser Phase aktuellen
Graphen (L, E ) und Residualgraphen (V , Rf ) erhalten bleiben:
1. Es gilt E ⊆ Rf .
2. Aus p ∈ La und q ∈ Lb folgt df (p, q) ≥ b − a.
3. Jeden Pfad in (V , Rf ) von s nach t der Länge k gibt es auch in
(L, E ).
Zu Beginn der Phase sind die drei Invarianten erfüllt.
216 / 369
Der Algorithmus von Dinitz
Wir beginnen damit, die Kanten Ek+1 zu entfernen, denn diese
kommen auf keinem Pfad von s nach t der Länge k vor. Insbesondere
hat t danach den Ausgangsgrad Null. Die Invarianten wurden nicht
verletzt. Wir starten jetzt eine Tiefensuche von s aus und stoppen,
wenn wir einen Knoten mit Ausgangsgrad Null finden. Die
Tiefensuche liefert damit einen Pfad π = (p0 , . . . , pℓ ) mit p0 = s,
(pd−1 , pd ) ∈ Ed für 1 ≤ d ≤ ℓ und pℓ hat keine ausgehende Kante in
(L, E ). Die Tiefensuche kostet O(n) Zeit. Wir unterscheiden jetzt die
Fälle pℓ 6= t und pℓ = t.
Im ersten Fall sei pℓ 6= t. Dann gibt es in (L, E ) keinen Pfad von s
nach t, der pℓ benutzt, denn pℓ hat Ausgangsgrad Null. Also gibt es
nach der dritten Invariante auch in (V , Rf ) keinen Pfad von s nach t
der Länge k, welcher pℓ benutzt. Wir entfernen die Kante (pℓ−1 , pℓ )
aus E . Dies verändert Rf nicht und die Invarianten bleiben erhalten.
Danach starten wir eine neue Tiefensuche bei s (oder setzen die alte
bei pℓ−1 fort).
217 / 369
Der Algorithmus von Dinitz
Der zweite Fall ist etwas subtiler. Es sei jetzt pℓ = t. Nach der ersten
Invariante ist π = (p0 , . . . , pℓ ) ein Verbesserungspfad. Wir bezeichnen
mit Eπ die Menge der Kanten von π:
Eπ = { (pd−1 , pd ) | 1 ≤ d ≤ ℓ }
Für ρ = min { c(e) − f (e) | e ∈ Eπ } gilt ρ > 0. Wir definieren einen
neuen Fluss fπ vermöge


f (x, y ) + ρ für (x, y ) ∈ Eπ
fπ (x, y ) = f (x, y ) − ρ für (y , x) ∈ Eπ


f (x, y )
sonst
Dadurch erhöhen wir den Fluss entlang des Pfades π um den Wert ρ
und haben mindestens eine der Kanten e ∈ Eπ gesättigt; dies
bedeutet, für den veränderten Fluss fπ gilt fπ (e) = c(e) für eine
Kante e ∈ Eπ . Wir durchlaufen den Pfad π nochmals und entfernen
alle gesättigten Kanten aus E . Danach starten wir eine neue
Tiefensuche bei s.
218 / 369
Der Algorithmus von Dinitz
Da sich der Fluss verändert hat, müssen wir die Invarianten bezüglich
Rfπ überprüfen. Hierfür müssen wir untersuchen, wie sich der
Residualgraph verändert hat. Die gesättigten Kanten e vom Pfad π
sind in Rfπ nicht mehr vorhanden. Das Löschen war also problemlos.
Alle ungesättigten Kanten (pd−1 , pd ) auf π sind weiterhin in Rfπ und
auch in (L, E ) vorhanden.
Wir müssen dennoch vorsichtig sein, denn wenn f (x, y ) zu f (x, y ) + ρ
vergrößert wird, so verringert sich gleichzeitig f (y , x) zu f (y , x) − ρ.
Solche Kanten (y , x) können in Rfπ neu hinzukommen. Sie sind aber
nicht in (L, E ) aufgenommen worden. Die erste Invariante bleibt
trivialerweise erhalten. Die zweite und dritte müssen jedoch
nachgewiesen werden.
219 / 369
Der Algorithmus von Dinitz
Die neuen Kanten (y , x) haben alle die Eigenschaft, dass y ∈ Ld+1
und x ∈ Ld für ein d ≥ 0 gilt. Wir definieren jetzt eine Menge R, die
wir schrittweise in Rπf transformieren und die ebenfalls die drei
Invarianten erfüllt, wenn wir bei den Bedingungen R anstelle von Rf
einsetzen. Die Distanz in R bezeichnen wir mit dR . Zu Anfang besteht
R aus den Kanten Rf ohne die gesättigten Kanten von Eπ . Die
Invarianten sind erfüllt. Sei jetzt R ′ = R ∪ { (y , x) } für ein beliebiges
Paar (y , x) ∈ Ld+1 × Ld . Wir wollen zeigen, dass die Invarianten für
R ′ mit entsprechender Distanz dR ′ gelten. Die erste Invariante bleibt
erhalten, weil wir eine Kante in R ′ hinzunehmen. Betrachte jetzt
p ∈ La und q ∈ Lb . Benutzt ein kürzester Pfad von p nach q in R ′
nicht die Kante (y , x), so gilt b − a ≤ dR (p, q) = dR ′ (p, q). Benutzt
dieser Pfad die Kante, so können wir dR ′ (p, q) wie folgt errechnen:
dR ′ (p, q) = dR (p, y )+1+dR (x, q) ≥ (d +1−a)+1+(b−d) = b−a+2
Dies zeigt die zweite Invariante.
220 / 369
Der Algorithmus von Dinitz
Um schließlich die dritte Invariante zu zeigen, betrachten wir einen
Pfad der Länge k von s nach t in R ′ . Benutzt er nicht die Kante
(y , x), so ist es ein Pfad in R und damit auch in (L, E ), da die
Invarianten für R gelten. Benutzt er die Kante, so erhalten wir den
folgenden Widerspruch:
k = dR ′ (s, t) = dR (s, y ) + 1 + dR (x, t) ≥ (d + 1) + 1 + (k − d) = k + 2
Dies zeigt die dritte Invariante. Über mehrere dieser Schritte kann
man von R aus die Menge Rfπ erhalten. Daher gelten die Invarianten
für Rfπ .
221 / 369
Der Algorithmus von Dinitz
Nach jeweils O(n) Schritten verliert E eine Kante, also gibt es nach
O(mn) Schritten keine Ausgangskante bei s. Dies beendet die Phase.
Die Distanz von s nach t im aktuellen Residualgraphen ist nach der
zweiten Invariante mindestens k. Andererseits gibt es in (L, E ) keinen
Pfad von s nach t. Nach der dritten Invariante gibt es dann auch in
Rf keinen Pfad der Länge k. Daher muss im aktuellen
Residualgraphen df (s, t) ≥ k + 1 gelten. Nach höchstens n Phasen
gilt df (s, t) = ∞. Dann haben wir einen maximalen Fluss berechnet,
und die Laufzeit ist insgesamt durch O(mn2 ) beschränkt.
222 / 369
Beispiel zum Algorithmus von Dinitz
Wir betrachten den Algorithmus von Dinitz auf dem folgenden
Flussnetzwerk:
x 9
3
s
9
3
9
9 y
9
5
9
t
3
223 / 369
Beispiel zum Algorithmus von Dinitz
Die erste Phase des Algorithmus von Dinitz beginnen wir mit dem
Nullfluss. Der Fluss, sein zugehöriger Residualgraph und der
resultierende Levelgraph am Anfang dieser Phase sind wie folgt:
x 0
0
s
0
0
0
x
0
0
0
s
t
0
0 y
t
y
x
s
t
y
224 / 369
Beispiel zum Algorithmus von Dinitz
Nach Hinzufügen des Verbesserungspfades (s, x, y , t) mit Wert 3
ergibt sich zu Beginn der zweiten Phase das folgende Bild:
x
x
3
s
3
s
t
3
y
t
y
x
s
t
y
225 / 369
Beispiel zum Algorithmus von Dinitz
Der Fluss der Kante (y , x) ist −3; daher hat sie noch freie Kapazität
8. Also hat der – in diesem Fall eindeutige – Verbesserungspfad den
Wert 8. Nach Hinzufügen dieses Pfades zum Fluss erhalten wir:
3
x 8
s
8
x
8
5
8
8
s
t
3
8 y
t
y
s
y
Zu Beginn der dritten Phase ist nun t nicht im Levelgraphen
enthalten. Der berechnete Fluss mit Wert 11 ist somit maximal. Der
zugehörige minimale Schnitt wird durch die drei Kanten (s, x), (y , x)
und (y , t) definiert.
226 / 369
Der Algorithmus von Dinitz
Die Laufzeit zur Berechnung maximaler Flüsse wurde in den letzten
Jahren weiter verbessert und ist Gegenstand aktueller Forschung. Der
Algorithmus von Dinitz ist robust und einfach zu implementieren; er
spielt daher auch in der Praxis weiterhin eine wichtige Rolle. Von
Dinitz stammt auch eine lesenswerte Betrachtung über die historische
Entwicklung der Fluss-Algorithmen ( Dinitz’ Algorithm: The Original
”
Version and Even’s Version“ in Essays in Memory of Shimon Even,
LNCS, 2006).
227 / 369
Erinnerung: Mastertheorem II
Wir erinnern uns im Folgenden an das Mastertheorem II aus den
Grundlagen.
Satz 10.1 (Mastertheorem II)
Sei r > 0,
Pr
i=0 αi
< 1 und für eine Konstante c sei
!
r
X
t(n) ≤
t(⌈αi n⌉) + c · n
i=0
Dann gilt t(n) ∈ O(n).
228 / 369
Medianberechnung in linearer Zeit
Gegeben sei ein Feld a[1 . . . n] von Zahlen. Gesucht ist das
⌊n/2⌋-kleinste Element in einer sortierten Reihenfolge der ai .
Allgemeiner sei 1 ≤ k ≤ n. Berechne SELECT(k, a[1 . . . n]).
Gesucht ist also das k-kleinste Element m, d.h., berechne
m ∈ { a[i] | 1 ≤ i ≤ n } mit:
|{i | a[i] < m}| < k
und
|{i | a[i] > m}| ≤ n − k
229 / 369
Median der Mediane
Bestimme ein Pivotelement als Median der Mediane aus 5: Wir teilen
das Feld in Fünferblöcken auf. In jedem Block wird der Median
bestimmt (mit 6 Vergleichen möglich). Wir bestimmen rekursiv den
Median p dieses Feldes (mit dem gesamten Algorithmus). Der Wert p
wird als Pivotelement im folgenden verwendet. Kosten: T ( n5 ).
230 / 369
Quicksortschritt
Mit dem Pivot p zerlege so, dass für gewisse m1 < m2 gilt:
a[i] < p
a[i] = p
a[i] > p
für 1 ≤ i ≤ m1
für m1 < i ≤ m2
für m2 < i ≤ n
Kosten: maximal n Schritte. Fallunterscheidung:
1. k ≤ m1 : Suche das k-te Element rekursiv in a[1], . . . , a[m1 ].
2. m1 < k ≤ m2 : Das Ergebnis ist p.
3. k > m2 : Suche das (k − m2 )-te Element in a[m2 + 1], . . . , a[n].
231 / 369
30 – 70 Aufteilung
Die Wahl des Pivots als Median-aus-Fünf ergibt die folgende
Ungleichungen für m1 , m2 :
3
n ≤ m2
10
und
m1 ≤
7
n
10
Damit ergeben sich die Kosten für den Rekursionsschritt als T ( 7n
10 ).
Denn: Die Hälfte der 5-er Mediane ist ≤ p. Dies betrifft also
(mindestens) n/10 der Blöcke. In jedem Block aus 5 Elementen sind
mindestens 3 kleiner oder gleich dem Blockmedian.
232 / 369
Zeitanalyse
Sei T (n) die Gesamtzahl der Vergleiche. Wir erhalten folgende
Rekursionsgleichung für T (n):
n
7n
T (n) ≤ T
+T
+ O(n)
5
10
Aus dem Mastertheorem II folgt damit T (n) ∈ O(n).
233 / 369
Zahl der notwendigen Schlüsselvergleiche
T (n) ≤ T
n
5
+T
7n
10
+
6n 2n
+
5
5
Hierbei ist 6n
5 der Aufwand für die Bestimmung der Blockmediane und
2n
der
Aufwand
für den Zerlegungsschritt ist.
5
Denn wir können bei der richtigen Positionierung des Medians der
Mediane jeweils in Fünferblöcken operieren und müssen daher aus
einem Fünferblock jeweils nur noch zwei Elemente mit dem
Pivotelement vergleichen.
7
9
Es ergibt sich, dass damit T (n) ≤ 16n gilt: mit 15 + 10
= 10
erhalten
9n
8n
8n
wir T (n) ≤ T ( 10) + 5 und damit T (n) ≤ 10 · 5 = 16n.
n
Der Term T 7n
10 wird im Mittel näher bei T 2 liegen, d.h., der
Medianalgorithmus verhält sich im Mittel besser.
In Praxis ist jedoch Quickselect die bessere Methode. Später.
234 / 369
Quicksort
Quicksort-Algorithmus 1962 von Hoare:
Wähle Pivotelement.
Zerlege das Feld in zwei Teilfelder mit Pivot als Trennung.
Nach linear vielen Vertauschungen sind die Elemente im linken Teilfeld
kleiner oder gleich Pivot, im rechten größer oder gleich Pivot.
Wende auf beide Teilfelder rekursiv den gleichen Algorithmus an.
Wichtig: die Wahl des Pivots.
Laufzeit ist optimal, falls das Pivotelement gleich dem mittleren
Element des Feldes (Median) ist.
In der Praxis bewährt:
die Median-aus-Drei-Methode.
235 / 369
Partitionieren
Zunächst geben wir die Prozedur zum Partitionieren eines Feldes A
(im Bereich ℓ bis r ) bzgl. eines Pivot-Elements P = A[p] an, wobei
ℓ < r und p ∈ {ℓ, . . . , r } gelte. Ergebnis dieser Prozedur ist ein Index
m ∈ {ℓ, . . . , r − 1}, der folgende Eigenschaften erfüllt:
A[i] ≤ P für alle ℓ ≤ i ≤ m
und
A[i] ≥ P für alle m + 1 ≤ i ≤ r .
Das rechte Teilfeld enthält (irgendwo) das Pivotelement.
236 / 369
Partitionieren
function partitioniere(A[ℓ . . . r ] : array of integer, p : integer) : integer
(* Partitioniere A[ℓ . . . r ] bzgl. A[p]; Rückgabewert = Index m *)
begin
P := A[p];
(* Pivot-Element merken *)
swap(A[ℓ], A[p]);
(* Pivot an erste Pos. stellen *)
x := ℓ − 1;
y := r + 1;
while x < y do
repeat x := x + 1 until A[x] ≥ P;
repeat y := y − 1 until A[y ] ≤ P;
if x < y then
swap(A[x], A[y ]);
endif
endwhile
return y
endfunction
237 / 369
Partitionieren
Man vergewissere sich, dass die geforderten Eigenschaften von dieser
Implementierung wirklich erfüllt werden, und dass es außerdem nicht
vorkommen kann, dass der linke bzw. rechte Zeiger“ (x bzw. y ) über
”
die Feldgrenze ℓ bzw. r hinauswandert.
Die vorgestellte Implementierung führt bis zu n + 2
Schlüsselvergleichen auf einem Feld mit n Elementen durch.
Jedes Element außer A[p] muss jedoch nur einmal mit P verglichen
werden.
Dies lässt sich durch eine andere Implementierung erreichen. (Übung)
Bei der Durchschnittsanalyse von Quicksort werden wir daher von
n − 1 Schlüsselvergleichen ausgehen. Außerdem gehen wir davon aus,
dass das Pivotelement die Felder am Ende trennt.
238 / 369
Quicksort
procedure quicksort(A[ℓ . . . r ] : array of integer)
begin
if ℓ < r then
p := Index des Median von A[ℓ], A[(ℓ + r ) div 2], A[r ];
m := partitioniere(A[ℓ . . . r ], p);
(* Feld bzgl. A[p] partitionieren *)
quicksort(A[ℓ . . . m]);
(* linkes Teilfeld sortieren *)
quicksort(A[m + 1 . . . r ]);
(* rechtes Teilfeld sortieren *)
endif
endprocedure
239 / 369
Quicksort, kleineres Teilfeld zuerst
procedure quicksort(A[ℓ . . . r ] : array of integer)
begin
if ℓ < r then
p := Index des Median von A[ℓ], A[(ℓ + r ) div 2], A[r ];
m := partitioniere(A[ℓ . . . r ], p);
(* Feld bzgl. A[p] partitionieren *)
if m − ℓ < r − m then
(* kleineres Teilfeld zuerst *)
quicksort(A[ℓ . . . m]);
(* linkes Teilfeld sortieren *)
quicksort(A[m + 1 . . . r ]);
(* rechtes Teilfeld sortieren *)
else
quicksort(A[m + 1 . . . r ]);
(* rechtes Teilfeld sortieren *)
quicksort(A[ℓ . . . m]);
(* linkes Teilfeld sortieren *)
endif
endif
endprocedure
240 / 369
Quicksort: Komplexität
Worst-case Der Quicksort-Algorithmus ist quadratisch:
In jedem Schritt enthält eines der beiden Teilfelder genau ein Element.
Mögliches Szenario: Liste bereits (fast) sortiert, Pivot ist stets das
erste oder letzte Element.
Hier: Durchschnittsanalyse unter der Annahme einer zufälliger
Auswahl des Pivotelements. (Alternativ: Feld ist zufällig angeordnet.)
Satz 11.1
Q(n) := P
die mittlere Anzahl der Schlüsselvergleiche.
H(n) := nk=1 k1 = n-te harmonische Zahl.
Dann gilt für Quicksort:
Q(n) = 2(n + 1)H(n) − 4n.
241 / 369
Quicksort: Durschnittsanalyse
Beweis: Für n = 1 gilt offensichtlich Q(1) = 0 = 2 · 2 · 1 − 4 · 1. Für
n ≥ 2 gilt:
n
Q(n) = (n − 1) +
= (n − 1) +
1X
[Q(i − 1) + Q(n − i)]
n
i=1
n
2X
n
i=1
Q(i − 1)
Dabei ist (n − 1) die Zahl der Vergleiche beim Pivotieren und
[Q(i − 1) + Q(n − i)] die mittlere Zahl der Vergleiche für das
rekursive Sortieren der beiden Teilhälften; dabei sind alle Positionen
für das Pivotelement gleich wahrscheinlich (deswegen der Faktor 1/n).
242 / 369
Quicksort: Durschnittsanalyse
Damit gilt:
nQ(n) = n(n − 1) + 2
n
X
i=1
Q(i − 1)
243 / 369
Quicksort: Durschnittsanalyse
Also:
nQ(n) − (n − 1)Q(n − 1) = n(n − 1) + 2
n
X
i=1
Q(i − 1)
−(n − 1)(n − 2) − 2
n−1
X
i=1
Q(i − 1)
= n(n − 1) − (n − 2)(n − 1) + 2Q(n − 1)
= 2(n − 1) + 2Q(n − 1)
Wir erhalten:
nQ(n) = 2(n − 1) + 2Q(n − 1) + (n − 1)Q(n − 1)
= 2(n − 1) + (n + 1)Q(n − 1)
244 / 369
Quicksort: Durschnittsanalyse
Q(n)
n+1
=
2(n − 1) Q(n − 1)
2(n − 1) 2(n − 2) Q(n − 2)
+
=
+
+
n(n + 1)
n
n(n + 1) (n − 1)n
n−1
=
n
X
2(k − 1)
k(k + 1)
k=1
= 2
n
X
(k − 1)
k(k + 1)
k=1
n
X
= 2
k=1
X
k
1
−
k(k + 1)
k(k + 1)
n
k=1
245 / 369
Quicksort: Durschnittsanalyse
Q(n)
n+1
= 2
"
= 2
n
X
k=1
"
n
X
1
1
−
k +1
k(k + 1)
n
X
k=1
k=1
n
X1
2
−
k +1
k
k=1
#
#
1
+ H(n) − 1 − H(n)
= 2 2
n+1
= 2H(n) +
4
− 4.
n+1
246 / 369
Quicksort: Durschnittsanalyse
Schließlich erhält man für Q(n):
Q(n) = 2(n + 1)H(n) + 4 − 4(n + 1)
= 2(n + 1)H(n) − 4n.
Es ist H(n) − ln n ≈ 0,57 . . . = Eulersche Konstante. Also:
Q(n) ≈ 2(n + 1)(0,57 + ln n) − 4n
≈ 2n ln n − 2,8n ≈ 1,38n log n − 2,8n.
Theoretische Grenze: log(n!) = n log n − 1,44n;
Quicksort ist im Mittel um 38% schlechter.
Die Durchschnittsanalyse der Median-aus-Drei Methode liefert
1,18n log n − 2,2n.
Dies ist im Mittel nur noch um 18% schlechter.
247 / 369
Quickselect
Algorithmus 12.1
function quickselect(A[ℓ . . . r ] : array of integer, k : integer) : integer
begin
if ℓ = r then
return A[ℓ]
else
p := random(ℓ, r );
m := partitioniere(A[ℓ . . . r ], p);
k ′ := (m − ℓ + 1);
if k ≤ k ′ then
return quickselect(A[ℓ . . . m], k)
else
return quickselect(A[m + 1 . . . r ], k − k ′ ) endif endif
endfunction
248 / 369
Durchschnittsanalyse von Quickselect
◮
Q(n) durchschnittliche Anzahl an Vergleichen von quickselect,
um das kte Element in einem Feld der Größe n zu finden.
Das Feld ist fest gewählt und entspricht einer festen
Permutation, mit π bezeichnen wir die zufällige Reihenfolge, in
der Pivot-Elemente gezogen werden. Es sei 1 ≤ k ≤ n fest. Im
Folgenden bezeichnen i, j Werte mit 1 ≤ i < j ≤ n.
Im Laufe von Quickselect (oder auch Quicksort) werden i und j
maximal einmal verglichen. Falls sie verglichen werden ist dann i
oder j aktuelles Pivotelement.
◮
Xij (π) := i wird mit j verglichen“ ∈ {0, 1}.
”
249 / 369
Durchschnittsanalyse von Quickselect
Unterscheide 3 Fälle:
1. Fall: i < j ≤ k. Xij (π) = i oder j wird als erstes
”
2
im Intervall [i, . . . , k] gezogen“ = k−i+1
X
X
1≤i<k i<j≤k
X
k −i
k −i +1
1≤i<k
X
1
=2
1−
k −i +1
Xij (π) = 2
1≤i<k
= 2(k − H(k))
wobei H(k) ∈ Θ(ln k) die harmonische Funktion ist.
2. Fall: k ≤ i < j, analog folgt Xij (π) =
X
X
k<j≤n k≤i<j
2
j−k+1
und
Xij (π) = 2(n − k + 1 − H(n − k + 1))
250 / 369
Durchschnittsanalyse: 1. und 2. Fall
Die beiden ersten Fälle ergeben zusammen einen linearen Term:
2n + 1 − H(k) − H(n − k + 1) = 2n − Θ(log n).
251 / 369
Durchschnittsanalyse von Quickselect
3. Fall: i < k < j Xij (π) =
X
X
2
j−i+1
Xij (π) = 2
X
X
1≤i<k k<j≤n
1≤i<k k<j≤n
=2
X 1≤i<k
<2
X
1≤i<k
1
j −i +1
1
1
+ ··· +
k −i +2
n−i +1
(ln(n − i + 1) − ln(k − i))
n
= 2 ln
k −1
252 / 369
Durchschnittsanalyse von Quickselect
◮
◮
◮
◮
1. Fall + 2. Fall zusammen ergeben < 2n
Mit kn ≤2n ergibt sich:
n
Q(n) < 2 n + ln k−1
≤ 2(1 + ln(2))n
n
:
Im Fall k = ⌈n/2⌉ folgt mit n1 2n ≤ ⌈n/2⌉
Q(n) > 2 (1 + ln(2)) n − c log(n) für ein geeignetes c
Das heißt, Q(n) = 2(1 + ln(2))n − log -Terme für k ≈ n/2.
Für die Median-Berechnung mit Quickselect werden im Mittel also
3,38n < 2 · 1,693147181n < 3,4n Vergleiche benötigt.
253 / 369
15. Vorlesung, 18.12.2012
Behandelte Themen:
◮
Fibonacci-Heaps.
◮
Amortisierte Zeitanalyse.
Anwendungen:
◮
Dijkstra, Prim.
254 / 369
Fibonacci-Heaps
Fibonacci-Heap H = Liste von Bäumen (also ein Wald):
Die Bäume sind knotenbeschriftet.
Alle Knoten, bis auf die Wurzel, können zusätzlich eine Marke tragen.
V = Knotenmenge.
key : V → N Beschriftung.
root bezeichnet stets eine der Wurzeln.
Heap-Bedingung:
∀x ∈ V : ist y ein Kind von x, so gilt: key (x) ≤ key (y )
255 / 369
Fibonacci-Heaps
◮
Die Eltern-Kind-Beziehung wird durch Zeiger realisiert, da die
Bäume unbalanciert sein werden.
◮
Im Gegensatz zu einem Standard-Heap müssen Indexrechnungen
also durch aufwendige Zeigeroperationen ersetzt werden.
◮
Operationen:
◮
1. merge,
◮
2. insert,
◮
3. delete min,
◮
4. decrease key.
256 / 369
Fibonacci-Heaps
◮
merge: Konkatenation zweier Listen — konstante Zeit.
◮
insert: Spezialfall von merge — konstante Zeit.
◮
merge und insert können (eventuell sehr lange) Listen
einelementiger Bäume erzeugen.
◮
Jede solche Liste ist ein Fibonacci-Heap.
257 / 369
delete min
◮
Sei H ein Fibonacci-Heap aus T Bäumen und n Elementen.
◮
Für einen Knoten x sei rank (x) = die Anzahl der Kinder von x.
◮
Für einen Baum B sei rank (B) = Rang der Wurzel von B.
◮
Sei rmax (n) der maximale Rang, der in einem Fibonacci-Heap mit
n Elementen auftreten kann.
◮
rmax (n) ≤ n.
◮
Später zeigen wir rmax (n) ∈ O(log n).
258 / 369
procedure delete min
1. Suche minimalen Schlüssel als Wurzel in einem Baum. Sei r der
Rang dieses Baumes. Zeit: O(T ). Alternativ gibt es einen Zeiger
auf das kleinste Element.
2. Trenne die Wurzel ab und ersetze den Baum durch die r
Teilbäume. Evtl. Marken entfernen. Zeit: O(T + r ).
3. Definiere Feld L[0, . . . , rmax (n)] mit L[i] = die Liste der Bäume
von Rang i. Zeit: O(T + rmax (n)).
4. for i := 0 to rmax (n) − 1 do
while |L[i]| ≥ 2 do
Entnehme zwei Bäume aus L[i].
Hänge den Baum mit dem größeren Schlüsselwert an der
Wurzel direkt unter die Wurzel des anderen Baumes und
füge diesen neuen Baum in L[i + 1] an.
endwhile
endfor
delete min erfordert also Zeit O(T + rmax (n)).
259 / 369
Bemerkung
Am Ende der Prozedur delete min gibt es für jeden möglichen Rang
höchstens einen Baum.
Insbesondere ist die Zahl der Bäume durch rmax (n) beschränkt.
260 / 369
decrease key
Kaskadenartige Schnitte: Sei x der Knoten, dessen Schlüssel
verkleinert werden soll.
1. Ist x die Wurzel, so kann der Schlüsselwert verkleinert werden.
Sei also x keine Wurzel und x = y0 , y1 , . . . , yk , . . . , root der Pfad
von x zur Wurzel. Für ein k ≥ 1 sei yk der erste (von x
verschiedene) Knoten, der keine Marke trägt.
2. Für 0 ≤ i < k trenne jetzt yi vom Elternknoten yi+1 ab und
entferne dabei die Marke von yi . (Für y0 = x ist evtl. eine Marke
vorhanden gewesen.) Damit wird yi für 0 ≤ i < k zu einer
unmarkierten Wurzel eines eigenen Baumes.
3. Falls yk keine Wurzel ist, markiere yk . (Kind verloren!)
261 / 369
decrease key
Es wird O(k + 1) Zeit benötigt. Beachte: Die Zahl der Marken hat
sich mindestens um k − 2 verringert, k ≥ 1. Die Anzahl der Bäume ist
nach der Prozedur decrease key durch T + k begrenzt.
262 / 369
decrease key
Definition 14.1
Ein Fibonacci-Heap ist eine Liste von Bäumen wie eingangs
beschrieben, die aus der leeren Liste unter Anwendung der
Operationen merge, insert, delete min und decrease key entstanden
ist.
Fibonacci-Heaps-Lemma
1. Sei x ein Knoten in einem Fibonacci-Heap, und ci das i-t älteste
Kind von x (d.h., c1 ist der erste Knoten, der Kind von x
geworden ist). Dann hat ci mindestens den Rang i − 2.
2. Hat x mindestens den Rang k, k ≥ 0, so enthält die Teilmenge
der Wurzel x zusammen mit den Teilbäumen von k Kindern
mindestens Fk+2 Knoten. Hierbei ist Fk+2 die (k + 2)-te
Fibonacci-Zahl (F0 = 0, F1 = 1, Fk+2 = Fk + Fk+1 für k ≥ 0).
263 / 369
Beweis Lemma
1. Sei c1 , c2 , . . . , ck die dem Alter nach absteigend geordnete Folge
der Kinder von x, und 1 ≤ i ≤ k. Dann ist c1 älter als c2 , c2 älter als
c3 , u.s.w. Zu dem Zeitpunkt, als ci unter den Knoten x (der zu diesem
Zeitpunkt eine Wurzel war) gehängt wurde, existierten also bereits die
Kinder c1 , . . . , ci−1 . Der Rang von x war also mindestens i − 1. Da
nur Bäume vom gleichen Rang zu einem Baum vereinigt werden,
hatte ci zu diesem Zeitpunkt mindestens den Rang i − 1. Der Knoten
ci kann inzwischen maximal ein Kind verloren haben. (In diesem Fall
wäre ci markiert.) Der Verlust eines weiteren Kindes hätte die
Abtrennung ci von x zur Folge gehabt. Es folgt die erste Behauptung
rank (ci ) ≥ i − 2 .
Die zweite Behauptung folgt dann mit Induktion und einem Bild.
264 / 369
Fibonacci-Zahlen
x k+1 = x k + x k−1 ⇐⇒ x k−1 (x 2 − x − 1) = 0
√
√
Die Zahlen 1+2 5 , 1−2 5 sind die beiden Lösungen der quadratischen
Gleichung x 2 − x − 1 = 0. Dies führt zu dem Ansatz:
√ !k
1+ 5
+b
2
Fk = a
√ !k
1− 5
2
Wegen F0 = 0 und F1 = 1 muss für a, b gelten:
a
Es folgt a =
√1 ,
5
b=
√
1+ 5
2
−1
√
.
5
a + b = 0,
√ + b 1−2 5
= 1.
265 / 369
Fibonacci-Zahlen

√ !k
1  1+ 5
Fk = √
−
2
5
Die Fibonacci-Zahlen wachsen exponentiell.
Also rmax (n) ∈ O(log n).

√ !k
1− 5 
2
266 / 369
Zusammenfassung der Zeitabschätzungen
1,2. merge, insert: in konstanter Zeit
3. delete min: O(T + log n), wobei T die Zahl der Bäume ist. Der
Summand log n ergibt sich aus rmax (n) ∈ O(log n).
4. decrease key: O(1) + O(k), wobei k ≥ 0 die Zahl der Marken sei,
um die sich der Fibonacci-Heap verringert hat.
267 / 369
Amortisierte Zeiten
Für die weitere Analyse einer Sequenz von Operationen betrachten wir
die gegen eine Potentialfunktion amortisierte Zeit.
Definition 14.2
Für einen Fibonacci-Heap H sei das Potential pot (H) gegeben durch
pot (H) := T + 2M ,
wobei T die Zahl der Bäume und M die Zahl der Marken seien.
Für eine Operation op sei ∆pot (op ) die Differenz des Potentials vor
und nach der Ausführung:
∆pot (op ) = pot (Heap nach op ) − pot (Heap vor op ) .
Die amortisierte Zeit einer Operation op sei
tamort (op ) = t(op ) + ∆pot (op ) .
268 / 369
Potentialfunktion
Die Potentialfunktion erfüllt:
◮
◮
pot (H) ≥ 0,
pot (∅) = 0.
Sei jetzt op 1 , op 2 , op 3 , . . . , op m eine Sequenz von m Operationen auf
einem zunächst leeren Fibonacci-Heap.
Dann gilt:
m
m
X
X
tamort (op i ) .
t(op i ) ≤
i=1
i=1
Bemerkung: Die Differenz ist gerade das Potential des erzeugten
Heaps.
Wegen pot (H) ∈ O(|H|) gilt
m
X
i=1
tamort (op i ) ∈
m
X
t(op i ) + θ(|H|).
i=1
Es genügt also eine Schranke für tamort (op ) zu bestimmen.
269 / 369
Bequemlichkeit
Für die weitere Rechnung ist es bequemer, sich bei der tatsächlich
verbrauchten Zeit zunächst von der O-Notation zu befreien. Durch die
Multiplikation mit einer geeigneten Konstanten können wir annehmen,
dass sich merge und insert in einem Schritt realisieren lassen. Die
Operation delete min benötigt höchstens T + log n und die Operation
decrease key höchstens k + 1 Zeitschritte. Die Wahl der Basis für den
Logarithmus ist in der Zeitanalyse unerheblich.
270 / 369
delete min
◮
tamort (merge) = t(merge) = 1. Denn das Potential der
konkatenierten Liste ist die Summe der Potentiale der
Einzellisten.
◮
tamort (insert) = t(insert)+∆pot (op ) = 1 + 1 = 2.
◮
Für delete min gilt t(delete min) ≤ T + log n, wobei T die Zahl
der Bäume zuvor und rmax (n) bis auf einen konstanten Faktor die
maximale Zahl der Bäume danach ist.
Die Zahl der Marken kann nur kleiner werden. Aus
∆pot (op ) ≤ −T + rmax (n) folgt daher
tamort (delete min) ≤ T + log n − T + rmax (n) ∈ O(log n) .
271 / 369
delete min
◮
Für decrease key gilt nach der obigen Bemerkung
t(decrease key) ≤ k + 1. Dabei verliert der Heap mindestens
k − 2 Marken, k ≥ 1, und erhält höchstens k neue Bäume.
∆pot (op ) = ∆(T ) + 2∆(M)
≤ k + 2 · (2 − k)
= 4−k
Also gilt tamort (decrease key) ≤ k + 1 + 4 − k = 5 ∈ O(1).
272 / 369
delete min
Satz 14.3
Für einen Fibonacci-Heap gelten die folgenden amortisierten Zeiten:
tamort (merge) ∈ O(1)
tamort (insert) ∈ O(1)
tamort (delete min) ∈ O(log n)
tamort (decrease key) ∈ O(1)
273 / 369
Anwendungen
Anwendung auf den Dijkstra- oder Prim-Algorithmus:
Für den Dijkstra-Algorithmus sei V die Randmenge und key die
ermittelte Distanz der Randknoten zum Quellknoten u (entsprechend
für Prim).
Sei n die Zahl der Knoten und e die Zahl der Kanten. Maximal werden
n insert-, e decrease key- und n delete min-Operationen durchgeführt.
274 / 369
Anwendungen
tDijkstra ≤
n · tamort (insert)
+ e · tamort (decrease key)
+ n · tamort (delete min)
∈ O(n + e + n log n)
= O(e + n log n)
Man beachte, dass sich für die Analyse des schlechtesten Falles keine
Verbesserung ergibt. Asymptotisch ist O(e + n log n) jedoch
mindestens genauso gut wie min(e · log n, n2 ). In vielen Fällen
n2
(n log n ≤ e ≤ log
n ) ist O(e + n log n) um den Faktor log n besser.
275 / 369
Teil 2: Berechenbarkeit
276 / 369
Grundlagen
Im Folgenden behandeln wir einige Grundlagen:
◮
Turingmaschinen (nicht-deterministisch, deterministisch)
◮
Konfigurationen
◮
Berechnungen,...
◮
Turingmaschinen können auf viele verschiedene äquivalente
Weisen definiert werden.
◮
Wir könnten Turingmaschinen auch durch andere äquivalente
Rechenmodelle ersetzen (z.B. Registermaschinen).
277 / 369
Turingmaschinen: Definition
Definition 15.1
Eine nichtdeterministische Turingmaschine mit k-Arbeitsbändern ist
ein Tupel M = (Q, Σ, Γ, δ, q0 , F , b)
◮
Q : endliche Menge der Zustände
◮
q0 ∈ Q : Startzustand
◮
◮
F ⊆ Q : Menge der Endzustände
Γ : endliches Bandalphabet
◮
Σ ( Γ : endliches Eingabealphabet
◮
b ∈ Γ \ Σ : Blanksymbol
◮
δ ⊆ Q × (Σ ∪ {b}) × Γk × Q × Γk × {L, R, N}k+1 :
Übergangsrelation.
L (R, N): bewege Kopf nach links (rechts, Neutral, also gar
nicht)
278 / 369
Turingmaschinen: Definition
Bei einer deterministischen k-Band Turingmaschine M ist δ eine
partiell definierte Funktion
δ : Q × (Σ ∪ {b}) × Γk → Q × Γk × {L, R, N}k+1 .
Soll M eine Funktion berechnen, so hat M zusätzlich ein
Ausgabealphabet Σ′ und für δ gilt:
δ : Q × (Σ ∪ {b}) × Γk → Q × Γk × {L, R, N}k+1 × (Σ′ ∪ {λ})
(λ ist das leere Wort).
279 / 369
Turingmaschinen: Konfigurationen
Definition 15.2
Eine Konfiguration α der Turingmaschine M bei Eingabe w ∈ Σ∗ ist
ein Tupel α = (q, u0 , v0 , u1 , v1 , . . . , uk , vk ), mit:
◮
q ∈ Q : aktueller Zustand der Turingmaschine
◮
u0 v0 = w b, v0 6= λ: Der Lesekopf für das Eingabeband liest
gerade das erste Symbol von v0 .
◮
∀i ∈ {1, . . . , k} : ui ∈ Γ∗ , vi ∈ Γ+ :
Das i-te Arbeitsband hat den Inhalt ui vi bb · · · und der i-te
Schreib/Lesekopf liest gerade das erste Symbol von vi .
Die Länge |α| von α ist |α| = max { |ui vi | | 1 ≤ i ≤ k }.
Für eine Einband-TM (ohne explizite Arbeitsbänder) schreiben wir
Konfigurationen häufig als Wörter:
uqv ∈ Γ∗ QΓ+
es gilt dann: |uqv | = Wortlänge von uv
Die TM ist dann im Zustand q und liest das erste Zeichen von v .
280 / 369
Turingmaschinen: Startkonfiguration, akzeptierende
Konfigurationen, . . .
1. Für die Eingabe w ∈ Σ∗ ist Start(w ) = (q0 , λ, w b, λ, b, . . . , λ, b)
die zu w gehördende Startkonfiguration.
Beachte: |Start(w )| = 1.
2. Für ein d ∈ δ und Konfigurationen α, β schreiben wir α ⊢d β,
falls die Anweisung“ d auf die Konfiguration α anwendbar ist,
”
und die Konfiguration β ergibt.
[
⊢d .
3. Es sei ⊢M =
d∈δ
4. Mit Accept bezeichnen wir die Menge der akzeptierenden
Konfigurationen (aktueller Zustand ist aus F ⊆ Q).
5. Beachte: α ⊢M β ⇒ |α| − |β| ∈ {−1, 0, 1}
281 / 369
Turingmaschinen: Berechnungen, Protokolle
1. Eine Rechnung von M bei Eingabe w ist eine Folge von
Konfigurationen α0 , α1 , . . . , αm mit
◮
◮
Start(w ) = α0
∀1 ≤ i ≤ m : αi−1 ⊢M αi
Die Berechnung ist erfolgreich, falls αm ∈ Accept.
2. Das Protokoll dieser Rechnung ist die Folge d0 d1 . . . dm−1 ∈ δ ∗
mit αi ⊢di αi+1
282 / 369
Turingmaschinen: akzeptierte Menge, Zeit- und Platzbedarf
1. Der Zeitbedarf (bzw. Speicherbedarf) der Berechnung
α0 , α1 , . . . , αm ist m (bzw. max{|αi | | 0 ≤ i ≤ m}).
2. M hat bei Eingabe w den Zeitbedarf (bzw. Speicherbedarf)
N ∈ N, falls jede Berechnung von M bei Eingabe w Zeitbedarf
(bzw. Speicherbedarf) ≤ N hat.
3.
L(M) = {w ∈ Σ∗ | ∃ erfolgreiche Berechnung von M bei Eingabe w }
ist die von M akzeptierte Menge.
283 / 369
Komplexitätsklassen
Seien t : N → N und s : N → N monoton wachsende Funktionen.
DTIME(t) = {L ⊆ Σ∗ | es existiert deterministische Turingmaschine M mit L = L(M), die auf allen Eingaben
der Länge n Zeitbedarf max{t(n), n + 1} hat.}
NTIME(t) = {L ⊆ Σ∗ | es existiert nichtdeterministische Turingmaschine M mit L = L(M), die auf allen Eingaben der Länge n Zeitbedarf max{t(n), n + 1}
hat.}
DSPACE(s) = {L ⊆ Σ∗ | es existiert deterministische Turingmaschine M mit L = L(M), die auf allen Eingaben
der Länge n Speicherbedarf s(n) hat.}
NSPACE(s) = {L ⊆ Σ∗ | es existiert nichtdeterministische Turingmaschine M mit L = L(M), die auf allen Eingaben der Länge n Speicherbedarf s(n) hat.}
Für eine Komplexitätsklasse C ist CoC = {L | Σ∗ \ L ∈ C} die Menge
der Komplemente der in C enthaltenen Sprachen.
284 / 369
Komplexitätsklassen
Wir werden die Klassen DTIME(t) und NTIME(t) nur für
Funktionen t(n) mit ∀n ∈ N : t(n) ≥ n betrachten.
Dies erlaubt, die gesamte Eingabe zu lesen, da wir tatsächlich immer
n + 1 Schritte erlauben.
Wir werden die Klassen DSPACE(s) und NSPACE(s) nur für
Funktionen s(n) ∈ Ω(log(n)).
Dies erlaubt, eine Position i ∈ {1, . . . , n} im Eingabestring auf einem
Arbeitsband abzuspeichern.
285 / 369
Wichtige Komplexitätsklassen
Gebräuchlichen Abkürzungen:
L = DSPACE(log(n))
(2)
NL = NSPACE(log(n))
[
P =
DTIME(nk )
(3)
NP =
(5)
(4)
k≥1
[
NTIME(nk )
k≥1
PSPACE =
[
k≥1
DSPACE(nk ) =
[
NSPACE(nk )
(6)
k≥1
Die Gleichung = in (5) ist als Satz von Savitch bekannt (kommt
noch).
286 / 369
Beziehungen zwischen Komplexitätsklassen
PSPACE = IP
?
NP
?
NP ∩ CoNP
?
P
?
6=
NSPACE(n) = CoNSPACE(n)
? (1. LBA Problem)
DSPACE(n)
6=
S
S
k
k
DSPACE(log
(n))
=
k≥1 NSPACE(log (n))
k≥1
NL
?
L
6=
Es gibt noch viele weitere Komplexitätsklassen: Besuchen Sie doch
den complexity zoo
(http://qwiki.caltech.edu/wiki/Complexity Zoo)
287 / 369
Beispiele
◮
◮
◮
◮
{an b n c n | n ≥ 1} ∈ L
{w $w R | w ∈ Σ∗ }, {ww R | w ∈ Σ∗ } ∈ L
{w $w | w ∈ Σ∗ }, {ww | w ∈ Σ∗ } ∈ L
Die Menge PRIM = {p ∈ 1{0, 1}∗ | p ist Binärcodierung einer
Primzahl } ist in P.
Agrawal, Kayal und Saxena haben 2002 gezeigt, dass PRIM ∈ P
gilt, vorher war nur PRIM ∈ NP ∩ CoNP bekannt.
288 / 369
Aufzählbarkeit und Entscheidbarkeit
◮
Eine Sprache L ⊆ Σ∗ heißt aufzählbar, wenn es eine
Turingmaschine M mit L = L(M) gibt.
◮
Eine Sprache L ⊆ Σ∗ heißt entscheidbar, wenn es eine
Turingmaschine M gibt, die auf alle Eingaben entweder in einem
Zustand Ja“ oder in einem Zustand Nein“ hält; und es gilt
”
”
w ∈ L genau dann, wenn sie in Ja“ hält.
”
Satz 16.1
1. Ist L ⊆ Σ∗ entscheidbar, so auch das Komplement L = Σ∗ \ L.
2. L ⊆ Σ∗ ist genau dann entscheidbar, wenn L und das
Komplement L aufzählbar sind.
289 / 369
Einbandmaschinen und Reduktionen
◮
Jede Turingmaschine lässt sich durch eine Einbandmaschine
simulieren. (Beweis: Spurtechnik.) Die Simulation benötigt
linearen Platz und quadratischen Mehraufwand in der Zeit.
◮
Sind L ⊆ Σ∗ und L′ ⊆ Σ′∗ , so bezeichnet L ≤ L′ (bis auf
Weiteres), dass sich L auf L′ reduzieren lässt.
◮
Eine Reduktion ist dabei eine total definierte berechenbare
Funktion f : Σ∗ → Σ′∗ mit
w ∈ L ⇐⇒ f (w ) ∈ L′ .
◮
◮
Sei L ≤ L′ und L′ entscheidbar, dann ist L entscheidbar.
Sei L ≤ L′ und L′ aufzählbar, dann ist L aufzählbar.
290 / 369
Kodierungen als Bitfolgen
Für mathematische Objekte X bezeichnen wir mit hX i ∈ { 0, 1 }∗ eine
Standardkodierung als Bitfolge.
Hierbei kann X alles Mögliche sein: eine Zahl, ein Wort über einem
Alphabet Σ, ein Graph, eine Turingmaschine oder ein Tupel.
Ist z.B. M = (Q, Σ, Γ, δ, q0 , F , b) eine Turingmaschine, so bezeichnet
hMi ∈ { 0, 1 }∗ ihre Kodierung.
Ist M = (Q, Σ, Γ, δ, q0 , F , b) eine Turingmaschine und w ∈ Σ∗ ein
Wort, so bezeichnet hM, w i ∈ { 0, 1 }∗ eine Kodierung von dem Paar
(M, w ).
291 / 369
Universelle Turingmaschine
Satz 16.2 (Turing)
Es gibt eine universelle Turingmaschine U mit
L(U) = { hM, w i ∈ { 0, 1 }∗ | w ∈ L(M) }
Folgerung 16.3 (Turing)
Die folgenden Sprachen sind aufzählbar aber nicht entscheidbar:
◮
◮
◮
Nichtleerheit: H = { hMi ∈ { 0, 1 }∗ | L(M) 6= ∅ }
Spezielles Halteproblem: H0 = { hMi ∈ { 0, 1 }∗ | ε ∈ L(M) }
Selbstanwendung: Hs = { hMi ∈ { 0, 1 }∗ | hMi ∈ L(M) }
292 / 369
Universalität vs. Leerheit
Folgerung 16.4 (Turing)
Für Σ 6= ∅ ist folgenden Sprache nicht aufzählbar noch ist ihr
Komplement aufzählbar:
{ hMi ∈ { 0, 1 }∗ | L(M) = Σ∗ }
Sei hMi die Kodierung einer Turingmaschine M. Dann konstruiere
eine Turingmaschine M ′ , die wie folgt arbeitet: M ′ akzeptiert alle
Eingaben w 6= ε. Ist w = ε, so simuliert M ′ die Maschine M. Es folgt
H0 = { hMi ∈ { 0, 1 }∗ | ε ∈
/ L(M) } ≤ { hMi ∈ { 0, 1 }∗ | L(M) 6= Σ∗ }
Konstruiere jetzt M ′′ mit:
L(M ′′ ) = { w ∈ Σ∗ | M akzeptiert nicht ε in der Zeit |w | }
Es folgt
H0 ≤ { hMi ∈ { 0, 1 }∗ | L(M) = Σ∗ }
293 / 369
Satz von Rice
Satz 16.5 (Rice)
Sei P eine nicht triviale Eigenschaft aufzählbar Sprachen. Dann ist P
unentscheidbar, d.h., die folgende Sprache ist unentscheidbar.
{ hMi ∈ { 0, 1 }∗ | P(L(M)) ist wahr }
Beweis: Seien Mi für i = 0, 1 zwei Turingmaschinen mit
P(L(Mi )) = i mit 0 = falsch“ und 1 = wahr“.
”
”
Ohne Einschränkung gilt L(M0 ) = ∅ und insbesondere L(M1 ) 6= ∅.
Für eine gegebene Turingmaschine M konstruiere eine Turingmaschine
M ′ , die wie folgt arbeitet:
Eingabe ist ein Wort w ∈ Σ∗ . Zunächst simuliert M ′ in ersten Phase
M auf ε und ignoriert w . Sie macht dann und nur dann weiter, wenn
ε ∈ L(M) gilt. In der zweiten Phase akzeptiert M ′ die Eingabe w
genau dann, wenn w ∈ L(M1 ).
294 / 369
Beweisforsetzung
Es gilt
ε ∈ L(M) ⇐⇒ L(M ′ ) 6= ∅ ⇐⇒ L(M ′ ) = L(M1 ) ⇐⇒ P(L(M ′ ))
Also
H0 = { hMi ∈ { 0, 1 }∗ | ε ∈ L(M) } ≤ { hMi ∈ { 0, 1 }∗ | P(L(M)) = 1 }
295 / 369
Fleißige Biber
Ein Biber ist eine deterministische Turingmaschine B mit Σ = { 1 }
und Γ = { 1, 0 } = { 1, b } sowie Q = { 1, . . . , n }. Wir setzen
|B| = |Q|.
Wir sagen B(0) = n, falls B auf Eingabe ε hält und dann genau n mal
eine 1 auf dem Band steht.
Für jedes n ∈ N ist die Anzahl der Biber B mit |B| ≤ n endlich. Daher
ist die folgende Funktion von N nach N total definiert:
bb(n) = max { B(0) | |B| ≤ n }
Satz 16.6 (Castoridae)
Die Funktion n 7→ bb(n) wächst echt schneller als jede
(Turing-)berechenbare Funktion. Insbesondere ist bb : N → N
unberechenbar.
296 / 369
Biberbeweise
Sei f : N → N durch eine Turingmaschine berechenbar. Es gibt eine
weitere Turingmaschine Mg mit Σ = { 1 } und Γ = { 1, 0 } = { 1, b },
die auf Eingabe |1 ·{z
· · 1} den Wert g (n) = 1 + f (2n) + f (2n + 1)
n-mal
berechnet.
Für jedes genügend große n gibt es nun einen Biber Bn mit höchstens
n Zuständen, der auf Eingabe ε die Ausgabe |1 ·{z
· · 1} erzeugt, danach
n-mal
können wir Mg simulieren und erhalten einen Biber, der auf ε die
Ausgabe
· · 1}
|1 ·{z
g (n)-mal
erzeugt. Dieser Biber benötigt höchstens n + O(1) Zustände. Für k
genügend groß gilt f (k) < bb(k) wegen
f (2n) + f (2n + 1) < bb(2n) ≤ bb(2n + 1)
297 / 369
Die imperative Programmiersprache IMP
Die Sprache IMPverfügt über drei Arten syntaktischer Konstrukte.
◮
Arithmetische Ausdrücke
(Aexp)
◮
Boolesche Ausdrücke
(Bexp)
◮
Anweisungen bzw. Programme
(Cmd)
298 / 369
Aexp
Syntaktische Definition:
a ::= n | X | (a + a) | (a − a) | (a · a)
Dabei ist n ∈ N, X eine Programmvariable. Die Klammern können
manchmal weggelassen werden, wenn dadurch keine Mehrdeutigkeit
entsteht.
Das heißt also:
1. Natürliche Zahlen und Variablen bilden arithmetische Ausdrücke.
2. Wenn a1 und a2 zu Aexp gehören, dann auch (a1 + a2 ),
(a1 − a2 ), (a1 · a2 ).
3. Sonst gehört nichts zu Aexp.
299 / 369
Bexp
Syntaktische Definition:
b ::= true | false | a1 < a2 |
¬b | b1 ∧ b2
Dabei seien a1 , a2 ∈ Aexp, b, b1 , b2 ∈ Bexp.
300 / 369
Cmd
Syntaktische Definition:
c ::= skip | X := a | c1 ; c2 |
if b then c1 else c2 fi | while b do c od
(X Variable, a ∈ Aexp, b ∈ Bexp, c, c1 , c2 ∈ Cmd.)
Ein Speicherzustand ist eine Belegung der Programmvariablen mit
natürliche Zahlen.
Einem gegebenen Programm c ∈ Cmd und einem Speicherzustand
σ ∈ Σ wird ein neuer Speicherzustand σ ′ ∈ Σ zugeordnet:
Cmd × Σ →p Σ
(Das p am Pfeil steht für partiell“).
”
301 / 369
Beispiel
X2 := 1;
while X1 > 1 do
X2 := X2 · X1 ;
X1 := X1 − 1
od
Σ besteht aus Zahlenpaaren, da nur X1 und X2 vorkommen:
Σ = {(n1 , n2 ) | n1 , n2 ∈ N}
Dabei sei für σ = (n1 , n2 ) ∈ Σ erfüllt:
σ(X1 ) = n1
σ(X2 ) = n2
302 / 369
Prädikatenlogik der 1. Stufe über N
Syntaktische Definition von Assn, der Menge der arithmetischen
Formeln :
A ::= b | ∃X : A | ∀X : A
Dabei ist b ∈ Bexp und X eine Variable.
Es gibt also freie und gebundene Variable. Sind alle Variablen in A
gebunden, so ist A ein Satz und ein Wahrheitswert definiert. Sind alle
Variablen frei, so erhalten wir A ∈ Bexp.
Es gilt also
Aexp ⊆ Bexp ⊆ Assn
Die Prädikatenlogik der 1. Stufe über N ist die folgende Teilmenge
von Assn:
{ F ∈ Assn | F ist ein gültiger Satz }
303 / 369
Der Gödel’sche Unvollständigkeitssatz
Satz 16.7 (Gödel)
Die folgende Sprache ist nicht aufzählbar:
Th(N) = { hF i ∈ { 0, 1 }∗ | F ∈ Assn ∧ F ist ein gültiger Satz }
Proof.
Idee: Zu einer Turingmaschine M konstruieren wir eine Formel FM in
zwei freien Variablen X , Y mit der Eigenschaft:
ε∈
/ L(M) ⇐⇒ ∀Y : FM (0, Y ) = false
Dies zeigt dann
{ hMi ∈ { 0, 1 }∗ | ε ∈
/ L(M) } ≤ Th(N)
304 / 369
Das Gödelsche β–Prädikat
Lemma 5.2.3 Das Prädikat β : N4 → B sei definiert durch
β(a, b, i, x) ⇔ x = a mod (1 + b(i + 1)).
Seien k, n0 , . . . , nk ∈ N. Dann gibt es Zahlen n, m ∈ N so, dass für
alle j ∈ {0, 1, . . . , k} und alle x ∈ N gilt:
β(n, m, j, x) ⇔ x = nj .
Beweis: Setze
m = (max{k, n0 , n1 , . . . , nk })!.
Zeige: ggT(1 + m(i + 1), 1 + m(j + 1)) = 1 (für 0 ≤ i < j ≤ k). Mit
dem Chinesischen Restsatz folgt die Existenz einer Zahl n, für die
n = ni mod (1 + m(i + 1)) für i ∈ {0, . . . , k} gilt.
305 / 369
Teil 3: Reduktionen und vollständige Probleme
Seien L ⊆ Σ∗ und L′ ⊆ Σ′ ∗ zwei Entscheidungs-Probleme.
Eine Reduktion von L auf L′ ist eine totale berechenbare Abbildung
f : Σ∗ → Σ′ ∗ mit: x ∈ L ⇐⇒ f (x) ∈ L′ .
Angenommen, wir kennen bereits einen Algorithmus zur Lösung von
L′ . Dann können wir die Frage x ∈ L wie folgt entscheiden:
1. Berechne den Wert f (x) ∈ Σ′ ∗
2. Entscheide mittels des Algorithmus für L′ ob f (x) ∈ L′ gilt.
x
✲
Mf
f (x)
✲
M L′
✲ ja
✲ nein
ML
306 / 369
Polynomialzeitreduktionen
Eine Reduktion f : Σ∗ → Σ′ ∗ von L auf L′ ist eine
Polynomialzeitreduktion, falls sich f durch eine deterministische
polynomialzeitbeschränkte Turingmaschine berechnen lässt.
Proposition
L′ ∈ P und ∃ Polynomialzeitreduktion von L auf L′
=⇒
L ∈ P.
Beweis: Angenommen L′ gehört zu DTIME(nk ) und f kann in Zeit
nℓ berechnet werden.
Für ein Eingabe x ∈ Σ∗ der Länge n kann f (x) in Zeit nℓ berechnet
werden.
Damit muss |f (x)| ≤ nℓ gelten, und es kann in Zeit (nℓ )k = nk·ℓ
entschieden werden, ob f (x) ∈ L′ (d.h. x ∈ L) gilt.
Gesamter Zeitbedarf: nℓ + nk·ℓ
307 / 369
Eine Bemerkung zu Polynomialzeit- und
logspace-Reduktionen
Wir schreiben auch
L ≤p L′
falls es eine Polynomialzeitreduktion von L auf L′ gibt.
Analog zu Polynomialzeitreduktion kann man auch
logspace-Reduktionen definieren, die sich in logarithmischem Platz
berechnen lassen müssen. Hier schreiben wir
′
L ≤log
m L
falls es eine logspace-Reduktion von L auf L′ gibt. (Das tiefgestellte m
steht für many-one“.)
”
Alle hier behandelten Reduktionen sind sogar in logarithmischem
Platz berechenbar. Die folgenden Folien sind daher zumeist mit der
feineren logspace-Reduzierbarkeit formuliert.
308 / 369
Beispiel für Polynomialzeitreduktion
Sei G = (A, B, E ) ein bipartiter Graph, d.h. A ∩ B = ∅ und
E ⊆ A × B.
Ein Matching M ist eine Teilmenge M ⊆ E so, dass keine zwei
Kanten aus M einen gemeinsamen Endknoten haben.
Wir zeigen, wie das Problem, ein Matching maximaler Größe zu
berechnen, sehr effizient auf die Berechnung eines Maximalflusses in
einem Netzwerk reduziert werden kann.
Ein Netzwerk ist ein Tupel N = (V , E , s, t, c), wobei:
◮ (V , E ) ein gerichteter Graph ist (d.h. E ⊆ V × V )
◮ s ∈ V ist die Quelle, t ∈ V ist die Senke, s 6= t,
◮ c : E → N ordnet jeder Kante e eine Kapazität c(e) > 0 zu.
Ein Fluß F ist eine Abbildung F : E → N mit:
P
P
◮ ∀v ∈ V \ {s, t} :
(v ,y )∈E F (v , y )
(x,v )∈E F (x, v ) =
(Flußerhaltung)
◮ ∀e ∈ E : F (e) ≤ c(e).
309 / 369
Beispiel für Polynomialzeitreduktion
Ein Fluß maximaler Größe kann in polynomialer Zeit mittels des
Max-Flow = Min-Cut-Theorems von Ford-Fulkerson (siehe Flüsse
”
und Schnitte“ im ersten Teil der Vorlesung) werden.
Die Reduktion von Maximum Matching auf Max-Flow startet mit
einem bipartiten Graphen G = (A, B, E ).
Konstruiere ein Netzwerk N = (V , E ′ , s, t, c) wie folgt:
◮
◮
◮
V = A ∪ B ∪ {s, t} (wobei s und t neue Knoten sind)
E ′ = E ∪ {(s, a) | a ∈ A} ∪ {(b, t) | b ∈ B}
c(x, y ) = 1 für alle (x, y ) ∈ E ′
Sei F : E ′ → N ein Fluß maximaler Größe in N.
Dann ist M = {e ∈ E | F (e) = 1} ein Matching maximaler Größe
in G .
310 / 369
Beispiel für Polynomialzeitreduktion
Sei G = (A, B, E ) ein bipartiter Graph:
A
B
311 / 369
Beispiel für Polynomialzeitreduktion
Füge eine Quelle s und eine Senke t an:
A
s
B
t
312 / 369
Beispiel für Polynomialzeitreduktion
Berechne einen maximalen Fluß:
A
s
B
t
313 / 369
Beispiel für Polynomialzeitreduktion
Hieraus ergibt sich die Lösung des Matchingproblems:
A
B
314 / 369
Vollständige Probleme
Definition
1. Sei C eine Komplexitätsklasse.
Ein Problem L ⊆ Σ∗ heißt schwierig für C oder kurz C-schwierig
(bzgl. logspace-Reduktionen), falls gilt: ∀K ∈ C : K ≤log
m L.
2. Sei C eine Komplexitätsklasse. Ein Problem L ⊆ Σ∗ heißt
C-vollständig (bzgl. logspace-Reduktionen), falls L schwierig für C
ist und zusätzlich L ∈ C gilt.
315 / 369
GAP ist NL-vollständig
Wir geben ein erstes Beispiel:
Satz 17.1
Das Grapherreichbarkeitsproblem GAP ist NL-vollständig.
Beweis:
GAP ∈ NL wurde bereits gezeigt.
Sei L ∈ NL, sei M eine nichtdeterministische
logspace-platzbeschränkte Turingmaschine mit L = L(M).
Wir definieren eine Reduktion f wie folgt: Für w ∈ Σ∗ sei
f (w ) = (G , s, t) mit:
◮ G = (V , E ) ist der gerichtete Graph mit:
V
E
◮
◮
= {α | α ist Konfig. von M bei Eingabe w , |α| ≤ log(|w |)}
= {(α, β) | α, β ∈ V , α ⊢M β}
s = Start(w )
t = die (o.B.d.A) eindeutige akzeptierende Konfiguration von M.
316 / 369
GAP ist NL-vollständig
Offensichtlich gilt:
w ∈ L(M) ⇐⇒ in G gibt es einen gerichteten Pfad von s nach t.
f kann offensichtlich in logarithmischen Platz berechnet werden.
317 / 369
2-SAT ist NL-vollständig
Satz 17.2
Das Problem 2-SAT = 2-KNF ∩ SAT ist NL-vollständig.
Aufgrund des Satzes von Szelepcsényi-Immermann genügt es, die
NL-Vollständigkeit von 2−NSAT = {Φ ∈ 2-KNF : Φ 6∈ SAT } zu
zeigen.
318 / 369
NL-Schwierigkeit
◮
2−NSAT ist NL-schwierig:
Sei GAP das Grapherreichbarkeitsproblem. Wir zeigen
GAP ≤log
m 2−NSAT. Sei G = (V , E ) ein gerichteter Graph und
s, t ∈ V . Aus jedem Knoten u machen wir eine Variable gleichen
Namens und aus jeder Kante (u, v ) ∈ E eine Implikation u ⇒ v ,
also die Klausel ¬u ∨ v . Desweiteren fügen wir die Klauseln s und
¬t hinzu.
Offensichtlich ist die so konstruierte Formel unerfüllbar, wenn in
G ein Weg von s nach t existiert.
Ist ein solcher Weg nicht vorhanden, so können alle Variablen,
deren zugehörige Knoten von s aus erreichbar sind, zu wahr und
alle übrigen zu falsch gesetzt werden. Dies definiert eine die
Formel erfüllende Belegung.
319 / 369
2−NSAT liegt in NL
Gegeben sei eine 2-KNF-Formel Φ in den Variablen x1 , . . . , xn .
Wir konstruieren einen Graphen mit Knotenmenge
V = {x1 , . . . , xn , x1 , . . . , xn }.
Jede Klausel α ∨ β lesen wir als Implikation und führen daher zwei
Kanten α → β und β → α ein.
α ∨ β ⇔ (α ⇒ β) ∧ (β ⇒ α)
∗
Behauptung: Es gibt genau dann einen Knoten x und Pfade x −→ x
∗
sowie x −→ x, wenn Φ unerfüllbar ist.
Somit kann die Nichterfüllbarkeit von Φ mit Hilfe des NL-Algorithmus
für Grapherreichbarkeit überprüft werden.
320 / 369
Beweis der Behauptung
,,⇒” ist einfach: Die Klauseln, welche zu den Kanten gehören, die die
Pfade bilden, ergeben die Implikationen x ⇒ ¬x und ¬x ⇒ x. Wir
können also weder x noch ¬x auf wahr setzen.
,,⇐”: Nun nehmen wir an, dass für jede Variable x höchstens einer
∗
∗
der Pfade x −→ x oder x −→ x existiert.
Wir können annehmen, dass genau einer dieser Pfade existiert:
∗
∗
Denn existiert weder x −→ x noch x −→ x, so füge die Kante x → x
hinzu. (D.h. C = x ∨ x = x)
321 / 369
Beweis der Behauptung
∗
Angenommen, wir hätten durch Hinzunahme von x −→ x einen Kreis
mit α und α erzeugt.
Dann benutzt dieser Kreis die Kante x → x, also erhalten wir eines
∗
der folgender Bilder, wobei −→ alte Kanten bezeichnet.
∗
∗
∗
∗
α −→ x → x −→ α −→ α −→ x
∗
∗
∗
∗
α −→ x → x −→ α −→ x → x −→ α
∗
Damit hatte der ursprüngliche Graph einen Pfad x −→ x, im
Widerspruch zur Annahme. Durch Wiederholung der Hinzunahme von
Kanten erreichen wir, dass schließlich immer genau einer dieser Pfade
∗
∗
existiert: x −→ x oder x −→ x.
322 / 369
2-SAT ist NL-vollständig
∗
Wir setzen jetzt x zu wahr, falls x −→ x und zu falsch, wenn
∗
x −→ x. Diese Belegung ist erfüllend: Wir betrachten eine beliebige
Klausel C = α ∨ β und nehmen an, dass β = falsch gilt (sonst ist C
ohnehin schon erfüllt). Dann gibt es nach der Konstruktion der
∗
Belegung einen Weg β −→ β. Außerdem gibt es wegen der Klausel C
die Kanten α → β und β → α. Wir erhalten somit den Weg
∗
α → β −→ β → α.
Damit gilt α = wahr. Also ist die Klausel erfüllt.
323 / 369
Teil 4: NP-Vollständigkeit
Satz 17.3
Falls es eine NP-vollständige Sprache gibt, so auch eine in
NTIME(n):
∃L : L ist NP-vollständig ⇒ ∃L̃ ∈ NTIME(n) : L̃ ist NP-vollständig.
Beweis: Sei L ein NP-vollständiges Problem.
Es existiert eine Konstante k > 0 mit L ∈ NTIME(nk ).
Aus dem Translationssatz für Zeitklassen folgt
Padnk (L) ∈ NTIME(n).
Sei nun L′ ∈ NP beliebig.
log
⇒ L′ ≤log
m L ≤m Padnk (L)
log
′
Da ≤log
m transitiv ist, folgt L ≤m Padnk (L).
⇒ Padp(n) (L) ist NP-vollständig.
324 / 369
Der Satz von Cook und Levin
Sei Σ0 = {¬, ∧, ∨, ⇒, ⇔, 0, 1, (, ), x}.
Sei A ⊆ Σ∗0 die Menge aller aussagenlogischen Formeln über der
Variablenmenge V = x1{0, 1}∗ .
A ⊆ Σ∗0 ist deterministisch kontextfrei und gehört damit zu
DTIME(n).
Sei SAT = {F ∈ A | F ist erfüllbar}.
(Eine aussagenlogische Formel F ist erfüllbar, wenn es eine Belegung
B : Var(F ) → {true, false} der in F vorkommenden Variablen mit
Wahrheitswerten gibt, unter der sich F zu true auswertet.)
Satz von Cook (und Levin)
SAT ist NP-vollständig.
325 / 369
Beweis des Satzes von Cook/Levin
(A) SAT ∈ NP: Für ein F ∈ Σ∗0 überprüfen wir F ∈ SAT“ wie folgt:
”
1. Teste in Zeit O(|F |) ob F ∈ A gilt.
2. Falls JA“, rate eine Belegung B : Var(F ) → {true, false}.
”
3. Akzeptiere, falls F sich unter der Belegung B zu true auswertet.
(B) SAT ist NP-schwierig.
Sei L ∈ NP.
Zu w ∈ Σ∗ konstruieren wir eine Formel f (w ) mit
w ∈L
⇐⇒ f (w ) erfüllbar .
Die Abbildung f wird logspace berechenbar sein.
Sei M = (Q, Σ, Γ, δ, q0 , F , b) eine p(n)-zeitbeschränkte
nichtdeterministische Turingmaschine mit L = L(M)
(p(n) ist ein Polynom).
Sei w = w1 w2 · · · wn ∈ Σ eine Eingabe der Länge n.
326 / 369
Beweis des Satzes von Cook/Levin
Wir stellen o.B.d.A. folgende Forderungen an M:
1. M hat nur ein Band, auf dem die Eingabe zu Beginn steht, und
auf das geschrieben werden darf.
2. F = {qf }, d.h. es gibt nur einen Endzustand.
3. Bei Eingabe w ∈ Σ∗ hält M nie, aber nach p(n) Schritten sind
wir genau dann im Endzustand, wenn w von M akzeptiert wird.
4. Nach p(n) Schritten ist der Schreib-Lesekopf wieder auf der
Ausgangsposition.
5. (q, a, q ′ , a′ , D), (q, b, p ′ , b ′ , D ′ ) ∈ δ =⇒ a = b, a′ = b ′ , D = D ′
Nur hinsichtlich des Folgezustand q ′ haben wir also eine
nichtdeterministische Wahl. Idee: Siehe nächste Folie.
327 / 369
Übergänge als Regelsystem
Die Übergänge einer TM können als Ersetzungssystem wie bei
Grammatiken gedeutet werden.
Für ρ = (q, a, q ′ , a′ , R) ∈ δ erhalten wir qa −→ q ′ a′ .
Für ρ = (q, a, q ′ , a′ , L) ∈ δ erhalten wir bqa −→ q ′ ba′ .
Wir splitten die Regeln in mehrere Teilregeln auf. Hierfür gibt es für
jeden Übergang ρ einen neuen Zustand qρ und auch ggf. qρ′ . 1.
Ersetze qa −→ q ′ a′ durch:
qa −→ qρ a und qρ a −→ q ′ a′ .
2. Ersetze bqa −→ q ′ ba′ durch:
q −→ qρ , qρ a −→ qρ′ a′ und bqρ′ −→ q ′ b für jedes b.
328 / 369
Beweis des Satzes von Cook/Levin
Aus Punkt (1) folgt, dass jede von der Startkonfiguration erreichbare
Konfiguration durch ein Wort aus
Conf = {buqv b | q ∈ Q; u, v ∈ Γ∗ ; |uv | = p(n)}
beschrieben werden.
Die Startkonfiguration ist bq0 w bp(n)+1−n .
Wegen Punkt (2) und (4) sind die akzeptierenden Konfigurationen
diejenigen aus bqf Γp(n) b.
Notation: Für ein α ∈ Conf schreiben wir
α = α[−1]α[0] · · · α[p(n)]α[p(n) + 1]
wobei α[−1] = b, α[0], . . . , α[p(n)] ∈ Q ∪ Γ, α[p(n) + 1] = b.
329 / 369
Beweis des Satzes von Cook/Levin
Definiere die Menge der 4-Tupel
∆ = {(a, b, c, b) | a, b, c ∈ Γ}
∪ {(c, b, q, p), (b, q, a, b), (q, a, d, a′ ) | (q, a, p, a′ , ←) ∈ δ, c, b, d ∈ Γ}
∪ {(c, b, q, b), (b, q, a, p), (q, a, d, a′ ) | (q, a, p, a′ , N) ∈ δ, c, b, d ∈ Γ}
∪ {(c, b, q, b), (b, q, a, a′ ), (q, a, d, p) | (q, a, p, a′ , →) ∈ δ, c, b, d ∈ Γ}
Wegen Punkt (5) gilt dann für alle α, α′ ∈ b(Q ∪ Γ)∗ b mit |α| = |α′ |:
α, α′ ∈ Conf und α ⊢M α′
⇐⇒
α ∈ Conf und ∀i ∈ {0, . . . , p(n)} : (α[i − 1], α[i], α[i + 1], α′ [i]) ∈ ∆.
330 / 369
Beweis des Satzes von Cook/Levin
Beispiel:
Falls (q, a, p, a′ , ←) ∈ δ ist folgende lokale Bandänderung für alle
b ∈ Γ möglich:
Position
i−1
i
i+1
α
=
···
···
b
q
a
···
···
α′
=
···
···
p
b
a′
···
···
Falls (q, a, p, a′ , →) ∈ δ ist folgende lokale Bandänderung für alle
b ∈ Γ möglich:
Position
i−1
i
i+1
α
=
···
···
b
q
a
···
···
α′
=
···
···
b
a′
p
···
···
331 / 369
Beweis des Satzes von Cook/Levin
Eine Rechnung von M können wir nun als Matrix beschreiben:
α0
α1
= b
= b
α0,0
α1,0
α0,1
α1,1
..
.
...
...
αp(n) = b αp(n),0 αp(n),1 . . .
α0,p(n)
α1,p(n)
b
b
αp(n),p(n) b
Für jedes Tripel (a, i, t) (a ∈ Q ∪ Γ, −1 ≤ i ≤ p(n) + 1,
0 ≤ t ≤ p(n)) sei x(a, i, t) aussagenlogische Variable.
Interpretation: x(a, i, t) = true genau dann, wenn zum Zeitpunkt t
das i-te Zeichen der aktuellen Konfiguration ein a ist.
332 / 369
Beweis des Satzes von Cook/Levin
Als Teilformeln definieren wir folgende Hornformeln:
^^
Konsistenzformel C (n) =
(¬X (a, i, t) ∨ ¬X (b, i, t)).
i,t a6=b
Randformel
R(n) =
^
t
X (b, −1, t) ∧
Startformel
S(w ) =
X (qo , 0, 0) ∧
Accept-Formel
^
1≤i≤n
^
X (b, p(n) + 1, t).
t
X (ai , i, 0) ∧
^
X (b, i, 0).
n<i
Accept(n) =X ($, 0, p(n)).
333 / 369
Beweis des Satzes von Cook/Levin
Übergangsformel
D(n) =
^
i≥0, t>0
(a,b,c)∈(Γ∪Q)3
X (a, i − 1, t − 1) ∧ X (b, i, t − 1) ∧ X (c, i + 1, t − 1)
→
_
d∈Γ∪Q mit
(a,b,c,d)∈∆
X (d, i, t) .
Endformel
ϕ(w ) = C (n) ∧ R(n) ∧ S(w ) ∧ Accept(n) ∧ D(n).
Diese Formel ist in konjunktiver Normalform.
Falls M deterministisch ist, dann ist es sogar eine Hornformel.
Die Klauseln, welche nur negative Literale enthalten, sind alle
Klauseln in C (n) und die in D(n), bei denen die Disjunktion leer ist.
334 / 369
Beweis des Satzes von Cook/Levin
Die Formel
ϕ′ (w ) = C (n) ∧ R(n) ∧ S(w ) ∧ D(n)
ist immer erfüllbar.
Die erfüllenden Belegungen entsprechen Rechnungen von M.
Am Wert Accept(n) können wir einer solchen Belegung ansehen, ob
sie erfolgreich ist.
335 / 369
P Vollständigkeit von HORNSAT
Aus dem Beweis ergibt sich unmittelbar:
HORNSAT ist P-vollständig.
336 / 369
Weitere NP-vollständige Probleme: (1) SAT ∩ KNF
Definition: Literale, KNF
Ein Literal x̃ ist eine aussagenlogische Variable oder die Negation
einer aussagenlogischen Variablen.
Statt ¬x schreiben wir auch x. Außerdem sei x = x.
Sei KNF (bzw. DNF) die Menge der aussagenlogischen Ausdrücke in
konjunktiver Normalform (bzw. disjunktiver Normalform):
DNF = {F | F ist Disjunktion von Konjunktionen von Literalen}
KNF = {F | F ist Konjunktion von Disjunktionen von Literalen}
Fakt: Jede aussagenlogische Formel F gibt es äquivalente Formeln
DNF(F ) ∈ DNF und KNF(F ) ∈ KNF.
337 / 369
Weitere NP-vollständige Probleme: (1) SAT ∩ KNF
Beispiel:
F =
^
i=1,...,k
_
j=1,...,m
x̃i,j
!
≡
_
f ∈{1,...,m}{1,...,k}
^
x̃i,f (i)
i=1,...,k
!
= F′
Beachte:
◮
|F | = m · k während |F ′ | = mk · k, d.h. eine KNF-Formel mit k
Disjunktionen der Länge m kann in eine äquivalente DNF-Formel
bestehend aus mk Konjunktionen der Länge k umgewandelt
werden.
◮
Für Formeln in DNF kann Erfüllbarkeit deterministisch in
quadratischer Zeit überprüft werden.
◮
Wir haben gezeigt, dass Erfüllbarkeit für Formeln in KNF
NP-vollständig ist.
Deswegen ist der exponentielle Blow-Up bei der Umwandlung von
KNF in DNF nicht überraschend.
338 / 369
SAT ∩ KNF ist NP-vollständig
Satz 17.4
SAT ∩ KNF ist NP-vollständig.
Beweis: Siehe Beweis von Cook/Levin.
339 / 369
3-SAT ist NP-vollständig
Definition: 3-SAT
Sei 3-KNF die Menge der Formeln in konjunktiver Form mit genau
drei Literalen je Klausel:
3-KNF := {F ∈ KNF | Jede Klausel in F enthält genau drei Literale}
3-SAT sei die Teilmenge der davon erfüllbaren Formeln:
3-SAT := 3-KNF ∩ SAT
Satz 17.5
3-SAT ist NP-vollständig.
Beweis: Das Problem ist NP. Daher ist in nur die NP-Schwierigkeit
zu zeigen.
Wir zeigen: SAT ∩ KNF ≤log
m 3-SAT.
Sei F eine KNF-Formel. Wir unterscheiden drei Fälle:
340 / 369
3-SAT ist NP-vollständig
1. F enthält eine Klausel (x̃) mit nur einem Literal.
Führe neue Variable y ein und ersetze (x̃) durch (x̃ ∨ y ) ∧ (x̃ ∨ y ).
Dies hat auf die Erfüllbarkeit von F keine Auswirkung.
2. F enthält eine Klausel (x̃ ∨ ỹ ) mit zwei Literalen.
Führe neue Variable z ein und ersetzte (x̃ ∨ ỹ ) durch
(x̃ ∨ ỹ ∨ z) ∧ (x̃ ∨ ỹ ∨ z).
3. F enthält Klauseln mit mehr als drei Literalen.
Sei also c = (x̃1 ∨ x̃2 ∨ · · · ∨ x̃k ) eine solche Klausel mit k ≥ 4
Literalen.
Führe k − 3 neue Variablen v (x̃3 ), v (x̃4 ), . . . , v (x̃k−2 ), v (x̃k−1 ) ein
und ersetzen c durch
c
′
=
x̃1 ∨ x̃2 ∨ v (x̃3 ) ∧
k−2
^
i=3
∧ v (x̃k−1 ) ∨ x̃k−1 ∨ x̃k .
v (x̃i ) ∨ x̃i ∨ v (x̃i+1 )
341 / 369
3-SAT ist NP-vollständig
Beachte: c ′ kann auch geschrieben werden als
c′ =
^
k−2
v (x̃i ) ⇒ x̃i ∨ v (x̃i+1 )
x̃1 ∨ x̃2 ∨ v (x̃3 ) ∧
i=3
∧ v (x̃k−1 ) ⇒ x̃k−1 ∨ x̃k .
Dass (3) nichts an der Erfüllbarkeit ändert folgt aus folgenden
Punkten:
(A) Sei σ eine erfüllende Belegung für c.
Dann muss σ(x̃i ) = 1 für ein 1 ≤ i ≤ k gelten.
Erweitere σ zu einer erfüllenden Belegung von c ′ durch:
(
1 falls j ≤ i
′
σ (v (x̃j )) =
0 falls j > i
342 / 369
3-SAT ist NP-vollständig
(B) Sei σ ′ eine erfüllende Belegung für c ′ .
Angenommen σ ′ (x̃i ) = 0 für alle 1 ≤ i ≤ k.
=⇒ σ ′ (v (x̃3 )) = 1 (da σ ′ (x̃1 ∨ x̃2 ∨ v (x̃3 )) = 1)
Mit Induktion folgt: σ ′ (v (x̃i )) = 1 für alle 3 ≤ i ≤ k − 1.
=⇒ σ ′ (v (x̃k−1 ) ∨ x̃k−1 ∨ x̃k )) = 0 Widerspruch!
343 / 369
Übersicht
1.) 2-SAT is NL vollständig. (Wurde hier nicht gezeigt.)
2.) HORNSAT is P vollständig.
3.) 3-SAT is NP vollständig.
4.) QBF is PSPACE vollständig. (Wurde hier noch nicht gezeigt.)
344 / 369
Integer Programming
Es sei
LinProg(Z) := {hA, bi | A ∈ Zm×n , b ∈ Zm×1 , ∃x ∈ Zn×1 : Ax ≥ b}
Zahlen aus Z werden hier binär kodiert.
Satz 17.6
LinProg(Z) ist NP-vollständig.
Beweis:
(1) LinProg(Z) ∈ NP:
Dies ist der schwierige Teil des Beweises, siehe z. B. Hopcroft,
Ullman; Introduction to Automata Theory, Languages and
Computation, Addison Wesley 1979
345 / 369
Integer Programming
(2) LinProg(Z) ist NP-schwierig.
Wir zeigen 3-SAT ≤log
m LinProg(Z).
Sei F = c1 ∧ c2 ∧ · · · ∧ cq eine Formel in 3-KNF.
Seien x1 , . . . , xn die Variablen in F .
Wir bilden das folgende System S von Z-Ungleichungen über den
Variablen xi , xi , 1 ≤ i ≤ n:
1. xi ≥ 0, 1 ≤ i ≤ n
2. xi ≥ 0, 1 ≤ i ≤ n
3. xi + xi ≥ 1, 1 ≤ i ≤ n
4. −xi − xi ≥ −1, 1 ≤ i ≤ n
5. x̃j1 + x̃j2 + x̃j3 ≥ 1, für jede Klausel cj = (x̃j1 ∨ x̃j2 ∨ x̃j3 ).
346 / 369
Integer Programming
(3) und (4)
=⇒
xi + xi = 1
(1) und (2)
=⇒
xi = 1, xi = 0 oder xi = 0, xi = 1
(5)
=⇒
in jeder Klausel cj hat mindestens ein Literal
x̃ij den Wert 1
Also: S lösbar genau dann, wenn F erfüllbar.
Größe von S: 4n + q Ungleichungen, 2n Variablen.
Schreiben wir S in Matrixform Ax ≥ b, so hat A (bzw. b)
(4n + q) × 2n (bzw. 4n + q) Einträge von Absolutbetrag ≤ 1.
Bemerkungen:
◮
◮
Obiger Beweis zeigt, dass LinProg(Z) bereits bei unärer
Kodierung NP-schwierig ist.
LinProg(Q) ∈ P. Dieser Nachweis ist sehr schwierig und beruht
auf der Ellipsoidmethode von Khachiyan.
347 / 369
Vertex Cover ist NP-vollständig
Eine Knotenüberdeckung (vertex cover) für einen ungerichteten
Graphen G = (V , E ) ist eine Teilmenge C ⊆ V so, dass für jede
Kante {u, v } ∈ E gilt: {u, v } ∩ C 6= ∅
Vertex Cover (VC) ist das folgende Problem:
Eingabe: Ein ungerichteter Graph G = (V , E ) und ein k ≥ 0.
Frage: Hat G Knotenüberdeckung C mit |C | ≤ k?
Satz 17.7
VC ist NP-vollständig.
Beweis:
(1) VC ∈ NP: Rate eine Teilmenge C der Knoten mit |C | ≤ k und
überprüfe danach in Polynomialzeit, ob C eine Knotenüberdeckung ist.
(1) VC ist NP-schwierig:
Wir zeigen 3-SAT ≤log
m VC.
348 / 369
Vertex Cover ist NP-schwierig
Sei
F = c1 ∧ · · · ∧ cq
eine Formel in 3-KNF, wobei
f
cj = (f
xj1 ∨ xf
j2 ∨ x
j3 ).
Wir konstruieren einen Graphen G (F ) wie folgt:
f
Zunächst bilden wir zu jeder Klausel cj = (f
xj1 ∨ xf
j2 ∨ x
j3 ) den
folgenden Graphen G (cj ):
xf
j3
xf
j1
xf
j2
349 / 369
Vertex Cover ist NP-schwierig
S
Der Graph G (F ) entsteht aus der disjunkten Vereinigung qj=1 G (cj )
aller dieser Teilgraphen G (cj ) durch Einfügen aller Kanten (x, x) (x
ist eine Variable aus F ).
Beispiel:
Für die Formel F = (x ∨ y ∨ z) ∧ (x ∨ s ∨ r ) ∧ (y ∨ s ∨ z) ∧ (x ∨ s ∨ r )
führt diese Konstruktion zu folgendem Graphen G (F ):
z
x
r
y
x
r
z
s
y
s
x
s
350 / 369
Vertex Cover ist NP-schwierig
Beachte: In G (F ) kann es kein Vertex Cover U mit weniger als 2q
Knoten geben, da in jedem der q Dreiecke mindestens 2 Knoten zu U
gehören müssen.
Behauptung:F ∈ 3-SAT genau dann, wenn G (F ) ein Vertex Cover U
mit |U| = 2q hat.
(A) Sei σ eine erfüllende Belegung für F .
Dann wird in jeder Klausel cj mindestens ein Literal xeji wahr.
Sei U eine Knotenmenge, die für jeden Teilgraphen G (cj ) genau ein
erfülltes Literal auslässt.
Dann gilt |U| = 2q und U ist ein Vertex-Cover.
351 / 369
Vertex Cover ist NP-schwierig
(B) Sei U ein Vertex-Cover mit |U| = 2q.
Dann enthält U aus jedem Teilgraphen G (cj ) genau zwei Knoten.
Definiere Belegung


1
σ(x) = 0


0
σ durch
falls eine Kopie von x nicht zu U gehört.
falls eine Kopie von x nicht zu U gehört.
falls alle Kopien von x und x zu U gehören.
Beachte: Da U ein Vertex Cover ist, und alle Kanten (x, x) in G (F )
vorhanden sind, wird keine Variable gleichzeitig auf 0 und 1 gesetzt.
Offensichtlich gilt σ(F ) = 1.
352 / 369
Hamilton-Kreis und Hamilton-Pfad sind NP-vollständig
Ein Hamilton-Pfad in einem gerichteten Graphen G = (V , E ) ist eine
Folge von Knoten v1 , v2 , . . . , vn mit
◮
◮
(vi , vi+1 ) ∈ E für alle 1 ≤ i ≤ n − 1 und
für jeden Knoten v ∈ V existiert genau ein 1 ≤ i ≤ n mit v = vi .
Ein Hamilton-Kreis ist ein Hamilton-Pfad v1 , v2 , . . . , vn mit
(vn , v1 ) ∈ E .
Es sei
HP = {G | G ist ein Graph mit einem Hamilton-Pfad}
HC = {G | G ist ein Graph mit einem Hamilton-Kreis}
Satz 17.8
HP und HC sind NP-vollständig (sogar für ungerichtete Graphen).
353 / 369
Hamilton-Kreis und Hamilton-Pfad sind NP-vollständig
Beweis: Wir zeigen nur die NP-Vollständigkeit von HC.
(A) HC ∈ NP: trivial.
(B) 3-SAT ≤log
m HC:
Sei F = c1 ∧ c2 ∧ · · · ∧ cm eine Formel in 3-KNF mit den Klauseln
c1 , . . . , cm in den Variablen x1 , . . . , xn .
Wir konstruieren einen Graphen G (F ), der genau dann einen
Hamilton-Kreis hat, falls F ∈ SAT gilt.
Zunächst definieren wir zu jeder Klausel c folgenden Graphen G (c):
b4
b3
a34
a33
a32
a31
b2
a24
a23
a22
a21
b1
a14
a13
a12
a11
354 / 369
Hamilton-Kreis und Hamilton-Pfad sind NP-vollständig
Beachte:
◮
In G (c) gibt es keinen Hamilton-Pfad von b1 nach b4 .
◮
Lässt man jedoch in G (c) mindestens einen der Wege
bj − aj1 − aj2 − aj3 − aj4 − bj+1 , j ∈ {1, 2, 3} weg, so gibt es
einen Hamilton-Pfad von b1 nach b4 .
Für eine Variable x sei {ci1 , . . . , cik } die Menge der Klauseln mit
x ∈ ci und {cj1 , . . . , cjl } die Menge der Klauseln mit x ∈ cj .
O.B.d.A i1 < · · · < ik , j1 < · · · < jℓ sowie ∀p, q : ip 6= jq .
Zu jeder Variablen x definieren wir nun einen Graphen G (x):
ei1 1
ei1 2
ei1 3
ei1 4
eik 1
eik 2 eik 3
eik 4
ej1 1
ej1 2
ej1 3
ej1 4
ejl 1
ejl 2
ejl 4
ejl 3
355 / 369
Hamilton-Kreis und Hamilton-Pfad sind NP-vollständig
G (xn )
G (ck )
G (ci )
G (c1 )
G (xj )
G (x1 )
Den Graphen G (F ) bilden wir durch Zusammenfügen der bisher
konstruierten Graphen nach dem folgenden Muster:
Zusätzlich benötigen wir für jede Klausel ck = (x̃k1 ∨ x̃k2 ∨ x̃k3 ) noch
Verbindungen zwischen dem Graphen G (ck ) und den Graphen G (xki ):
356 / 369
′′
ek4
′′
ek3
a34
b4
a33
a32
G (ck )
b3
a31
′′
ek1
′
ek4
a24
′′
ek2
G (xk3 )
G (xk2 )
a23
′
ek3
′
ek2
a22
′
ek1
a21
a14
a13
a12
ek3
ek4
b2
b1
a11
ek2
ek1
G (xk1 )
Hamilton-Kreis und Hamilton-Pfad sind NP-vollständig
Wir verbinden also für i ∈ {1, . . . , 3} und q ∈ {1, . . . , 4} den Knoten
aiq in G (ck ) mit dem Knoten ekq aus G (xki ) über einen neuen
Zwischenknoten.
357 / 369
Hamilton-Kreis und Hamilton-Pfad sind NP-vollständig
Beispiel: Sei F = (x1 ∨ x2 ∨ x3 ) ∧ (x1 ∨ x2 ∨ x3 ).
{z
} |
{z
}
|
c1
c2
G (x3 )
G (c2 )
G (c1 )
G (x2 )
G (x1 )
Dann ist G (F ) der folgende Graph:
358 / 369
Hamilton-Kreis und Hamilton-Pfad sind NP-vollständig
Behauptung: F ∈ SAT genau dann, wenn G (F ) einen
Hamilton-Kreis hat.
Angenommen σ ist eine erfüllende Belegung von F .
Wir erhalten einen Hamilton-Kreis für G (F ) wie folgt:
Der Weg führt über die erfüllten Literalen entsprechenden Knoten in
den G (xi ), wobei jedoch über die zuletzt eingefügten Verbindungen in
jedem G (ck ) genau eine Knotengruppe ai1 − ai2 − ai3 − ai4 besucht
wird.
Dies ist möglich, da in jeder Klausel mindestens ein Literal erfüllt ist.
Nachdem so alle G (xi ) durchwandert wurden, werden die in den
G (ck ) verbleibenden Knoten und die zugehörigen Knoten in den G (xi )
besucht.
Anschließend endet der Weg im Startknoten.
359 / 369
Hamilton-Kreis und Hamilton-Pfad sind NP-vollständig
Sei C ein Hamilton-Kreis für G (F ).
Dieser durchläuft in jedem der Graphen G (xi ) einen der beiden
Zweige.
Dies definiert eine erfüllende Belegung σ von F .
360 / 369
Rucksackproblem
Erinnerung: Beim Rucksack-Problem sind Zahlen a1 , . . . , an , s ∈ N
binär kodiert gegeben und die Frage
P ist, ob es eine Menge
I ⊆ { 1, . . . , n } gibt so, dass s = i∈I ai .
Satz 17.9
Das Rucksack-Problem ist NP-vollständig.
P
Wir können I ⊆ { 1, . . . , n } raten und dann s = i∈I ai verifizieren.
Daher liegt das Problem in NP.
Die NP-Schwierigkeit erhält man durch eine einfache Reduktion von
3-SAT auf dieses Problem.
361 / 369
Varianten algorithmischer Probleme
Beispiel 1: Traveling Salesman Problem (TSP)
Ein Reisender will eine gegebene Anzahl von Städten besuchen, ohne
dabei an einem Ort zweimal vorbeizukommen, und er will dabei den
kürzesten Weg nehmen. Das Wegenetz kann als gerichteter Graph
und die Wegstrecken als Gewichte auf den Kanten des Graphen
aufgefasst werden. Die Knoten stellen die Städte dar.
Sei G = (V , E , γ : E → N) ein gerichteter Graph mit Knotenmenge
V = {1, ..., n}, Kantenmenge E ⊆ V × V und den Kantengewichten
γ(e) > 0 für alle e ∈ E .
Ein Rundweg W ist gegeben durch eine Folge W = (x0 , . . . , xn ),
x0 = xn , xi 6= xj für 1 ≤ i < j ≤ n und (xi−1 , xi ) ∈ E für 1 ≤ i ≤ n.
Die Kosten γ(W ) des Rundweges W
Psind durch die Summe der
Kantengewichte gegeben: γ(W ) = ni=1 γ(xi−1 , xi ).
362 / 369
Varianten algorithmischer Probleme
(A) Entscheidungsvariante:
Eingabe: G = (V , E , γ : E → N) und ein k ≥ 0.
Frage: Existiert ein Rundweg mit Kosten ≤ k? D.h., existiert ein Weg
der alle Knoten genau einmal besucht und dessen Kosten höchstens k
sind?
(B) Berechnungsvariante:
Eingabe: G = (V , E , γ : E → N) und ein k ≥ 0.
Ziel: Falls ein Rundweg W mit γ(W ) ≤ k existiert, berechne ein
solches W .
(C) Optimierungsproblem:
Eingabe: G = (V , E , γ : E → N).
Ziel: Berechne einen kostenoptimalen Rundweg, falls ein Rundweg
existiert.
In allen drei Varianten
ist die Eingabegröße (bis auf einen konstanten
P
Faktor) |V | + e∈E log(γ(e))(+ log(k)).
363 / 369
Varianten algorithmischer Probleme
Aus praktischer Sicht ist Variante (C) (Optimierungsproblem) am
wichtigsten.
Aber: (A) in Polynomialzeit lösbar
lösbar.
=⇒
(C) in Polynomialzeit
Beweis:
1. Schritt:
Überprüfe, ob überhaupt ein Rundweg existiert:
P
Rufe hierzu (A) mit kmax = e∈E γ(e) auf.
Beachte: Es existiert ein Rundweg genau dann, wenn ein Rundweg mit
Kosten ≤ kmax existiert.
Im Folgenden nehmen wir an, dass ein Rundweg existiert.
364 / 369
Varianten algorithmischer Probleme
2. Schritt:
Berechne kopt = min{γ(W ) | W ist ein Rundweg} mittels binärer
Suche:
FUNCTION kopt
kmin := 1 (oder alternativ kmin := |V |)
while kmin < kmax do
min
kmitte := kmin + ⌈ kmax −k
⌉
2
if ∃ Rundweg W mit γ(W ) ≤ kmitte then kmax := kmitte
else kmin := kmitte + 1
endif
endwhile
return kmin
ENDFUNC
Beachte: Die Anzahl der Durchläufe P
durch die while-Schleife
ist
P
beschränkt durch log2 (kmax ) = log2 ( e∈E γ(e)) ≤ e∈E log(γ(e)).
365 / 369
Varianten algorithmischer Probleme
3. Schritt:
Berechne optimalen Rundweg wie folgt:
FUNCTION optimaler Rundweg
Sei e1 , e2 , . . . , em beliebige Auflistung von E
G0 := G
for i := 1 to m do
if ∃ Rundweg W in Gi−1 \ {ei } mit γ(W ) ≤ kopt then
Gi := Gi−1 \ {ei }
else
Gi := Gi−1
endif
endfor
return Gm
ENDFUNC
366 / 369
Varianten algorithmischer Probleme
Behauptung: Für alle i ∈ {0, . . . , m} gilt:
1. In Gi existiert ein Rundweg W mit γ(W ) = kopt .
2. Jeder Rundweg W in Gi mit γ(W ) = kopt benutzt alle Kanten
aus {e1 , . . . , ei } ∩ E [Gi ] (E [Gi ] = Menge der Kanten von Gi ).
Beweis:
1. Folgt sofort durch Induktion über i.
2. Angenommen es gibt einen Rundweg W in Gi mit γ(W ) = kopt
sowie eine Kante ej (1 ≤ j ≤ i) mit:
◮ e gehört zum Graphen G
j
i
◮ e gehört nicht zum Weg W
j
W ist auch ein Rundweg in Gj−1 . ⇒
W ist ein Rundweg in Gj−1 \ {ej }. ⇒
ej gehört nicht zu Gj und damit nicht zu Gi . Widerspruch
Konsequenz: Gm hat einen Rundweg W mit γ(W ) = kopt und jede
Kante von Gm gehört zu W .
⇒ Gm = W
367 / 369
Varianten algorithmischer Probleme
Beispiel 2: Vertex Cover (VC)
Sei G = (V , E ) ein ungerichteter Graph (d.h. E ⊆ V2 ).
Eine Teilmenge C ⊆ V ist eine Knotenüberdeckung von G falls für
jede Kante {u, v } ∈ E gilt: {u, v } ∩ C 6= ∅
(A) Entscheidungsvariante:
Eingabe: G = (V , E ) und ein k ≥ 0.
Frage: Hat G Knotenüberdeckung C mit |C | ≤ k?
(B) Berechnungsvariante:
Eingabe: G = (V , E ) und ein k ≥ 0.
Ziel: Falls eine Knotenüberdeckung C mit |C | ≤ k existiert, berechne
ein solches C .
(C) Optimierungsproblem:
Eingabe: G = (V , E ).
Ziel: Berechne eine möglichst kleine Knotenüberdeckung von G .
368 / 369
Varianten algorithmischer Probleme
Wieder gilt: (A) in Polynomialzeit lösbar =⇒ (C) in Polynomialzeit
lösbar.
Zeigen Sie dies als Übung.
369 / 369