Modul: Algorithmen und Berechenbarkeit WS2013/14

Modul: Algorithmen und Berechenbarkeit
WS 2013/14
Volker Diekert1
29. Januar 2014
1
Übungen: Tobias Walter
1 / 370
1. Vorlesung am 14.10.2013
Teil 1: Algorithmen
2 / 370
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 / 370
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 / 370
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
60.000
4.893
244
39
15
1 Stunde
Rechenzeit
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 / 370
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 / 370
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 / 370
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 / 370
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 / 370
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 / 370
Beispiel binäre Suchbäume
Beispiel 2.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 / 370
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 / 370
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 / 370
Untere Schranken / Beispiel Sortieren
Einer der schwierigen Aspekte der Algorithmentheorie ist die Suche
nach unteren Schranken.
Satz 2.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 / 370
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 2.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 / 370
Heiratssätze
Abbildung : Die Sympathie-Beziehungen zwischen den Herren und Damen.
16 / 370
Nobelpreis für Wirtschaftswissenschaften 2012
Laureaten waren US-Amerikaner Alvin E. Roth und Lloyd S. Shapley.
Es wurde 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.
17 / 370
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.
18 / 370
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).
19 / 370
Vermeidung von Scheidungen: Gale, Shapley 1962
Satz 3.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.
20 / 370
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 ′ ).
21 / 370
Der Gale-Shapley-Algorithmus berechnet eine stabile Heirat
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.
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 b 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 keiner Scheidung kommen und das Verfahren ist
stabil.
22 / 370
Das Verfahren ist für die Antragsteller optimal
Behauptung: Die Männer 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.
23 / 370
Beweis der Behauptung
Wir sagen, dass ein Paar (a, b) ∈ A × B instabil ist, wenn (a, b) in
keiner stabilen Heirat vorkommt.
Wir beweisen, hat a 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 liegt in
M, denn das erste realisierbare Paar wird nach Annahme ist (a, b).
Wegen (a, b) ∈ M ist (a, b ′ ) ∈
/ M. Daher gilt a > a′ aus Sicht von b ′ .
Treffen also (a, b), (a′ , b ′ ) aufeinander, so verlassen a und b ′ ihre
Partner und bilden ein neues Paar (a, b ′ ).
24 / 370
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
25 / 370
Lösung einfacher Rekursionsgleichungen
Satz 3.2
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
.
26 / 370
Beweis des Satzes
k = 0 : Es gilt n =b 0 =
und t(1) = g(1).
P1k−1
n
k > 0 : Daher t b = i =0 ai · g bin+1 mit Induktion,
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
+ g (n)
b i +1
ai · g
ai · g
n
bi
n
bi
+ a0 g
n
b0
.
27 / 370
Mastertheorem I
Korollar 3.3 (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.
28 / 370
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 ( bc )
nach dem Satz.
∞ X
a i
1
= nc ·
∈ O(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).
29 / 370
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 ·
∈
=
=
=
30 / 370
Beispiel Mergesort
Algorithmus 3.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
31 / 370
Mastertheorem II
Satz 3.4 (Mastertheorem II)
Sei r > 0,
Pr
i =0 αi
< 1 und für eine Konstante c sei
!
r
X
t(⌈αi n⌉) + c · n
t(n) ≤
i =0
Dann gilt t(n) ∈ O(n).
32 / 370
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(⌈αi n⌉) + cn
t(n) ≤
≤
i =0
r
X
i =0
!
γ⌈αi n⌉
+ cn
(mit Induktion)
≤ (γ(1 − ε) + c)n
≤ γn
33 / 370
Aufgabe aus der Scheinklausur 2014
Seien α > 1 und k ∈ N so gewählt, dass 0 ≤ p(n) ≤ nk , 0 < t(0) und
t(n) = αt(n − 1) + p(n) für alle n ≥ 1. Dann gilt
t(n) ∈ Θ(αn ).
Lösung:
Schreibe t(n) = f (n)αn für eine Funktion f (n) > 0. Für n ≥ 1 gilt:
t(n) = f (n)αn = αf (n − 1)αn−1 + p(n).
f (n) = f (n − 1) + p(n)/αn ≥ t(0).
Also gilt t(n) ∈ Ω(αn ).
Wegen α > 1 folgt ferner
f (n) ≤
X
i ≥0
i k /αi ∈ O(1).
Dies zeigt t(n) ∈ O(αn ). Zusammen erhalten wir t(n) ∈ Θ(αn ).
34 / 370
3. Vorlesung, 22.10.2013
Teile und Beherrsche – Divide and Conquer – Divide et impera
Beispiele für Divide and Conquer2 :
◮ Quicksort
◮ Mergesort
◮ Multiplikation ganzer Zahlen (Karatsuba 1960)
◮ Matrixmultiplikation (Strassen 1969)
2
Römisches Herrschaftsprinzip, auch von Machiavelli vorgeschlagen
35 / 370
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!
36 / 370
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.
37 / 370
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.
”
38 / 370
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:
A11
A12
B11
B12
C11
C12
=
A21
A22
B21
B22
C21
C22
39 / 370
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!
40 / 370
Matrixmultiplikation nach Strassen
Berechne das Produkt von 2 × 2 Matrizen mit 7 Multiplikationen:
M1
:=
M2
:=
(A12 − A22 )(B21 + B22 )
M1 + M2 − M4 + M6
C11
=
(A11 + A22 )(B11 + B22 )
C12
=
M4 + M5
(A11 − A21 )(B11 + B12 )
C21
=
M6 + M7
C22
=
M2 − M3 + M5 − M7
M3
:=
M4
:=
(A11 + A12 )B22
M5
:=
M6
:=
A11 (B12 − B22 )
M7
:=
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... )
41 / 370
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.
Der Coppersmith–Winograd-Algorithmus eine bessere theoretische
Schranke.
Beste bekannte Schranke 2012: O(n2,3727 ).
42 / 370
4. Vorlesung, 28.10.13
Probabilistische Verfahren
43 / 370
Probabilistische Verifikation der Matrixmultiplikation
Wir betrachten n × n Matrizen A = (aij ), B = (bij ), C = (cij ) mit
Koeffizienten in einem Halbring R wie etwa R = N, Z, Q, R, C oder
der boolesche Halbring B = { 0, 1 } = { ⊥, ⊤ }. Der Halbring R muss
nicht kommutativ sein, soll jedoch 0 6= 1 enthalten.
Es gilt
n
X
A·B =(
aik bkj ).
k=1
O(n2 )
Wir wollen in der Zeit
(genauer: mit O(n2 ) arithmetischen
Operationen) sehr sicher entscheiden können, ob A · B = C gilt.
44 / 370
Monte Carlo und Las Vegas Algorithem
Von Nord nach Süd: von Kogula (59. Breite) über Monte Carlo
(43. Breite) und Las Vegas (36. Breite) nach Tel Aviv (32. Breite)
Tabelle : Übersicht
korrekt
meistens korrekt
korrekt
meistens korrekt
gute Laufzeit
gute Laufzeit
meistens gute Laufzeit
meistens gute Laufzeit
Kogula: kleiner Ort in Estland
Monte Carlo: Mostly Correct
Las Vegas: Verified
C’est la vie
Typische Beispiele
1.
2.
3.
4.
Dijkstra-Algorithmus
Monte Carlo: Primzahlerkennung nach Rabin-Miller
Las Vegas: Quicksort
SAT-Solver
45 / 370
Monte-Carlo-Algorithmus von Rusin Freivalds (1977)
1. Wähle n mal zufällig und unabhängig ri ∈ { 0, 1 } und setze
r T = (r1 , . . . , rn ) ∈ { 0, 1 }n .
Also ist r ein Spaltenvektor, da r T Zeilenvektor.
P
2. Berechne s = (si ) = ( nk=1 bik rk ). Also s = B · r .
P
3. Berechne t = (ti ) = ( nk=1 aik sk ). Also t = A · s = A · B · r .
P
4. Berechne p = (pi ) = (ti − nk=1 cik rk ). Also p = (A · B − C ) · r .
5. Falls p 6= 0, dann A · B 6= C . Ansonsten Pr[A · B = C ] ≥ 1/2.
Beweis der letzten Zeile: Klar ist A · B = C =⇒ p = 0.
Sei also A · B − C = (dij ) und (i , j) fest gewählt mit dij 6= 0.
Es gilt
pi = dij rj +
X
dik rk = dij rj + y .
k6=j
46 / 370
Wahrscheinlichkeitsanalyse
Wegen
pi = dij rj +
X
k6=j
folgt
dik rk = dij rj + y und dij 6= 0
Pr[pi = 0] = Pr[pi = 0 ∧ y = 0] + Pr[pi = 0 ∧ y 6= 0]
= Pr[pi = 0 | y = 0] Pr[y = 0] + Pr[pi = 0 | y 6= 0] Pr[y 6= 0]
≤ Pr[ri = 0] Pr[y = 0] + Pr[ri = 1] Pr[y 6= 0]
= Pr[y = 0] /2 + Pr[y 6= 0] /2
= Pr[y = 0] /2 + (1 − Pr[y = 0])/2 = 1/2
Beachte, ist dij der einzige Nicht-Null-Eintrag, so folgt
Pr[pi = 0] = 1/2.
Durch k-fache Wiederholung kann die Fehlerwahrscheinlichtkeit unter
2−k gedrückt werden. Zeit: O(kn2 ).
47 / 370
Entwurfstrategien
Gierige Algorithmen – Greedy Algorithms
48 / 370
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).
49 / 370
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.
50 / 370
Beispiel Dijkstra-Algorithmus
Startknoten
0
1
3
∞
1
6
3
8
2
13
4
∞
3
∞
6
∞
51 / 370
Beispiel Dijkstra-Algorithmus
Startknoten
0
1
3
1
7
6
3
8
2
13
4
∞
3
∞
6
14
52 / 370
Beispiel Dijkstra-Algorithmus
Startknoten
0
1
3
1
7
6
3
8
2
4
11
7
13
3
6
14
53 / 370
Beispiel Dijkstra-Algorithmus
Startknoten
0
1
3
1
7
6
3
8
2
4
11
7
13
3
6
13
54 / 370
Beispiel Dijkstra-Algorithmus
Startknoten
0
1
3
1
7
6
3
8
2
4
9
7
13
3
6
13
55 / 370
Beispiel Dijkstra-Algorithmus
Startknoten
0
1
3
1
7
6
3
8
2
4
9
7
13
3
6
12
56 / 370
Beispiel Dijkstra-Algorithmus
Startknoten
0
1
3
1
7
6
3
8
2
4
9
7
13
3
6
12
57 / 370
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).
58 / 370
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
59 / 370
Problem negativer Kantengewichte
Startknoten
0
1
1
6
3
∞
3
8
2
-13
4
∞
∞
3
6
∞
60 / 370
Problem negativer Kantengewichte
Startknoten
0
1
1
6
3
7
3
8
2
-13
4
∞
∞
3
6
∞
61 / 370
Problem negativer Kantengewichte
Startknoten
0
1
1
6
3
7
3
8
2
-13
4
11
7
3
6
∞
62 / 370
Problem negativer Kantengewichte
Startknoten
0
1
1
6
3
7
3
8
2
-13
4
11
7
3
6
13
63 / 370
Problem negativer Kantengewichte
Startknoten
0
1
1
6
3
7
3
8
2
-13
4
9
7
3
6
13
64 / 370
Problem negativer Kantengewichte
Startknoten
0
1
1
6
3
7
3
8
2
-13
4
9
7
3
6
12
65 / 370
Problem negativer Kantengewichte
Startknoten
0
1
1
6
3
7
3
8
2
-13
4
9
7
3
6
12
66 / 370
Problem negativer Kantengewichte
Startknoten
0
1
−∞
3
−∞
6
3
8
2
4
Negativer Zyklus
-13
7
−∞
3
6
−∞
67 / 370
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.
68 / 370
Minimale Aufspannende Bäume
Definition 5.1
Ein Graph G = (V , E ) heißt zusammenhängend, wenn je zwei Knoten
durch einen Pfad verbunden sind.
Definition 5.2
Ein Baum ist ein zusammenhängender, kreisfreier, ungerichteter
Graph.
Bemerkung 5.3
Jeder Baum mit n Knoten besitzt genau n − 1 Kanten.
Definition 5.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).
69 / 370
Beispiel Prim-Algorithmus, 1
Startknoten
1
3
6
8
2
4
13
3
6
70 / 370
Beispiel Prim-Algorithmus, 2
Startknoten
1
3
6
8
2
4
13
3
6
71 / 370
Beispiel Prim-Algorithmus, 3
Startknoten
1
3
6
8
2
4
13
3
6
72 / 370
Beispiel Prim-Algorithmus, 4: Decrease Key
Startknoten
1
3
6
8
2
4
13
3
6
73 / 370
Beispiel Prim-Algorithmus, 5
Startknoten
1
3
6
8
2
4
13
3
6
74 / 370
Beispiel Prim-Algorithmus, 6
Startknoten
1
3
6
8
2
4
13
3
6
75 / 370
Beispiel Prim-Algorithmus, 7
Startknoten
1
3
6
8
2
4
13
3
6
76 / 370
Beispiel Prim-Algorithmus, 8
Startknoten
1
3
6
8
2
4
13
3
6
77 / 370
Beispiel Prim-Algorithmus, 9
Startknoten
1
3
6
8
2
4
13
3
6
78 / 370
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
79 / 370
Korrektheit des Prim-Algorithmus
Idee: Austauschsatz
Bi −1
y′
Ri −1
∈T
y
v (x)
6∈ T
x
80 / 370
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.
81 / 370
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.
82 / 370
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
6 C2 und C1 ∩ C2 = ∅ .
C1 6= ∅ =
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 , CP
2 ) mit s ∈ C1 und t ∈ C2 .
Für A ⊆ V , v ∈ V setze g (A, v ) = a∈A γ(av ).
Oder einheitlich:
X
g (A, B) =
γ(ab)
a∈A,b∈B
83 / 370
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 }
84 / 370
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.
85 / 370
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 ′ ).
86 / 370
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.)
87 / 370
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 )
88 / 370
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).
89 / 370
Korrektheitslemma
Lemma 6.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 )
90 / 370
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.
91 / 370
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)).
92 / 370
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)
93 / 370
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.
94 / 370
Phase
Algorithmus 6.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 ∗)
95 / 370
Berechnung eines minimalen Schnittes
Algorithmus 6.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 ∗)
96 / 370
Berechnung eines minimalen Schnittes
Algorithmus 6.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 . ∗)
97 / 370
Berechnung eines minimalen Schnittes
Algorithmus 6.4 Fortsetzung und Ende von Min Cut
if gphase ≤ g then
C1 := V \ {t};
C2 := {t};
g := gphase ;
endif
return (C1 , C2 , g )
endfunction
98 / 370
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.
99 / 370
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.
100 / 370
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.
101 / 370
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.
102 / 370
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.
103 / 370
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.
104 / 370
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.
105 / 370
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.
106 / 370
Übung: Wie verhält sich der Algorithmus bei negativen
Kantengewichten, bleibt er korrekt?
107 / 370
Antwort: siehe Übungen :-)
108 / 370
7. und 8. Vorlesung am 5. und 11.11.2013
Thema: Randomisierte Verfahren
◮
Las Vegas (Quicksort)
◮
Monte Carlo (Primzahlerkennung: Fermat bzw. Rabin-Miller,
Freivalds’ Verifikation der Matrixmultiplikation).
◮
Monte Carlo für minimale Schnitte nach David Karger und
Clifford Stein:
A New Approach to the Minimum Cut Problem
Journal of the ACM (1996) 601-640.
109 / 370
Wiederholung
Monte-Carlo-Algorithmen sind randomisierte Algorithmen, die bei
beschränkter Laufzeit mit einer kleinen Wahrscheinlichkeit ein falsches
Ergebnis liefern dürfen. Mostly Correct
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.
110 / 370
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 .
111 / 370
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)
112 / 370
Die maximale Anzahl minimaler Schnitte
Sei { 1, . . . , n } die Menge der Knoten. Die Anzahl aller Schnitte ist
durch
{C , C } ∅ =
6 C ⊆ V,∅ =
6 C = V \ C = 2n−1 − 1.
Es gibt also exponentiell viele Schnitte. Beachte jedoch: Sind
A1 , . . . , Am paarweise disjunkte Ereignisse, so können höchstens 1/p
eine W’keit größer oder gleich p haben. Daher gilt.
Die Anzahl der minimalen Schnitte ist durch n2 begrenzt, denn jeder
2
gefunden.
minimale Schnitt wird mit mindestens der W’keit n(n−1)
113 / 370
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 .
114 / 370
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.
115 / 370
Karger-Stein-Algorithmus
Sei G ein Eingabegraph
mit n Knoten und C ein fester minimaler
√
Schnitt, n = ( 2)k . (Wir vernachlässigen bewusst Rundungsfehler
und kleine n.)
1.) Ist n klein, dann löse das Problem direkt. Sonst:
2.) Wiederhole das
√ Folgende zweimal:
3.) Wähle n − n/ 2-mal eine Zufallskante und kontrahiere diese.
◮
◮
◮
◮
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 ′ .
4.) 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.
116 / 370
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 −
117 / 370
Lösung der Rekursion pk+1 ≥ pk − pk2 /4
Ansatz, definiere eine reelle Zahl zk ≥ 3 durch:
4
pk =
zk + 1
Also z3 = 3 wegen p3 = 1 und dann für k ≥ 3:
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
118 / 370
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
119 / 370
Finde minimale Schnitte mit hoher W’keit
Satz 6.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
2n
2 n
120 / 370
Das Geburtstagsparadoxon
Befinden sich mindestens 23 Personen in einem Raum, so die W’keit
mehr als 1/2, dass zwei Personen am gleichen Tag Geburtstag haben.
121 / 370
Herleitung vom Geburtstagsparadoxon
∀x ∈ R : (1 − x) ≤ e −x .
Gleichheit gilt nur bei x = 0. Falls |x| nahe bei Null ist, erhalten wir
eine sehr gute Abschätzung.
Angenommen, es gibt n mögliche Geburtstage und m Personen. Die
Wahrscheinlichkeit p(m, n), dass alle m Geburtstage verschieden sind,
ist dann:
m−1
Y
i
n−m+1
n n−1
1−
···
=
p(m, n) = ·
n
n
n
n
i =0
m−1
Y
i =0
i
1−
n
≤
m−1
Y
i
e− n = e−
Pm−1
i =0
i
n
= e−
m(m−1)
2n
i =0
Der Grenzwert 1/2 wird also spätestens im Bereich von m =
unterschritten. Für n = 365 (oder 366) ist dies 23.
√
2n ln 2
122 / 370
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
123 / 370
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.
124 / 370
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]
125 / 370
Bestimmung reguläre Ausdrücke: Gesamtschrittalgorithmus
Algorithmus 8.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
126 / 370
Bestimmung reguläre Ausdrücke: Einzelschrittalgorithmus
Algorithmus 8.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
127 / 370
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
128 / 370
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 ).
129 / 370
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]
130 / 370
Transitive Hülle
Algorithmus 8.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
131 / 370
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.
132 / 370
Transitive Hülle?
Algorithmus 8.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
133 / 370
Antwort
Antwort in den Übungen
134 / 370
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.
135 / 370
Floyd-Algorithmus
Algorithmus 8.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
136 / 370
10. Vorlesung, 18.11.2013
Thema: Dynamisches Programmieren
137 / 370
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 ):
138 / 370
Floyd-Algorithmus
Algorithmus 8.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
139 / 370
Floyd-Algorithmus
Algorithmus 8.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
140 / 370
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
k
A∗ = n−1
k=0 A .
141 / 370
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 ).
Ziel ist jedoch:
T (n) ∈ Θ(M(n)) ⊆ O(nlog2 7 ).
142 / 370
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.
143 / 370
Transitive Hülle mittels Teile und Beherrsche
Teile und Beherrsche = Divide et impera3
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 =
3
F∗
F ∗ BD ∗
D ∗ CF ∗ D ∗ + D ∗ CF ∗ BD ∗
.
Römisches Herrschaftsprinzip, auch von Machiavelli vorgeschlagen
144 / 370
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
P
i · M(n/2i )
2
k≥0
i
P
2
≤ c · k≥0 2+ε
· M(n)
T (n) ≤ c ·
(nach Mastertheorem)
(da M(n/2) ≤
1
2+ε M(n))
∈ O(M(n)).
145 / 370
Beispiel: Multiplikation einer Matrizenfolge
Multiplikation von links
(10 × 1)
(1 × 10)
(10 × 1)
(1 × 10)
(10 × 1)
146 / 370
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)
147 / 370
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)
148 / 370
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)
149 / 370
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)
150 / 370
Beispiel: Multiplikation einer Matrizenfolge
Multiplikation von links
Insgesamt: 400 Multiplikationen
151 / 370
Beispiel: Multiplikation einer Matrizenfolge
Multiplikation von rechts
(10 × 1)
(1 × 10)
(10 × 1)
(1 × 10)
(10 × 1)
152 / 370
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)
153 / 370
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)
154 / 370
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)
155 / 370
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)
156 / 370
Beispiel: Multiplikation einer Matrizenfolge
Multiplikation von rechts
Insgesamt: 40 Multiplikationen
157 / 370
Beispiel: Multiplikation einer Matrizenfolge
Multiplikation in optimaler Reihenfolge
(10 × 1)
(1 × 10)
(10 × 1)
(1 × 10)
(10 × 1)
158 / 370
Beispiel: Multiplikation einer Matrizenfolge
(10 × 1)
(1 × 10)
(10 × 1)
(10 × 1)
(1 × 10)
(10 × 1)
(1 × 10)
10 Multiplikationen
(10 × 1)
(1 × 1)
159 / 370
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)
160 / 370
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)
161 / 370
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)
162 / 370
Beispiel: Multiplikation einer Matrizenfolge
Insgesamt: 31 Multiplikationen
Dies ist optimal.
Wir haben also ein Optimum unter allen möglichen Klammerungen zu
bestimmen. Die Anzahl aller Klammerungen ist der Anzahl der
Binärbäumen. Für n Knoten ist die n-te Catalan-Zahl
2n
1
2n
Cn =
≈ 1.5 .
n+1 n
n
163 / 370
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 mit 5 = C3 =
1 6
4 3
164 / 370
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.
1
2
3
N
.
, M(n
, M(n
, . . . , M(n
Eingabe: Matrizenfolge M(n
2 ,n3 )
0 ,n1 )
1 ,n2 )
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 }
165 / 370
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]
166 / 370
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
Setze M[i , i ] = M(n
und berechne M[1, N] rekursiv:
i −1 ,ni )
M[i , j] = M[i , best[i , j]] · M[best[i , j] + 1, j].
167 / 370
Thema: Optimale Suchbäume
168 / 370
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.
169 / 370
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.
170 / 370
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
P(B) :=
ℓ(v ) · γ(v )
v ∈V
minimiert.
171 / 370
Optimale Suchbäume
Optimaler Suchbaum für 1, 2, 22 , 23 , 24 , 25 mittels Greedy-Strategie.
25
24
23
22
2
1
172 / 370
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
173 / 370
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
174 / 370
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.
175 / 370
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}.
176 / 370
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.
177 / 370
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 ′ ).
178 / 370
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.
179 / 370
Optimale Suchbäume
Die folgende Beobachtung (von Knuth) ist entscheidend.
Satz 8.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.
180 / 370
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.
181 / 370
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 : j1
Bi :
j2
1
i1
i2
..
2
..
.
n
.
ij
j
n
i
182 / 370
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.
183 / 370
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.
184 / 370
Optimale Suchbäume
Angenommen i2 = j2 , also m = 2. Wir erhalten das folgende Bild.
Beachte i1 ≥ j1 .
1
B ′ : i1
Bi : i1
i2 = j 2
j2
i2
..
..
.
ij
.
n
n
2
j
i
185 / 370
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 .
186 / 370
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.
187 / 370
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.
188 / 370
Optimale Suchbäume
Pα
✻
Pα (Bn )
Pα (Bℓ )
Pα (Bi )
Pα (Bk )
Pα (Bj )
✲
α0
α
189 / 370
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.
190 / 370
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!
191 / 370
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
192 / 370
Optimale Suchbäume
Laufzeit:
n−1 n−d
X
X
d=1 i =1
n−1
X
d=1
(1 + r [i + 1, i + d] − r [i , i + d − 1]) =
(n − d + r [n − d + 1, n] − r [1, d]) ≤
3 2
n ∈ Θ(n2 ).
2
Bemerkung 8.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 kann aus einem beliebigen Feld mit n Elementen ein
optimaler Suchbaum in Θ(n2 ) Schritten erzeugt werden.
193 / 370
13. Vorlesung, 26.11.2013
194 / 370
Mastertheorem II
Für die Medianberechnung in linearer Zeit wird das Mastertheorem II
benötigt.
Satz 9.1 (Mastertheorem II)
Sei r > 0,
Pr
i =0 αi
< 1 und für eine Konstante c sei
!
r
X
t(⌈αi n⌉) + c · n
t(n) ≤
i =0
Dann gilt t(n) ∈ O(n).
195 / 370
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(⌈αi n⌉) + cn
t(n) ≤
≤
i =0
r
X
i =0
!
γ⌈αi n⌉
+ cn
(mit Induktion)
≤ (γ(1 − ε) + c)n
≤ γn
196 / 370
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
197 / 370
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 ).
198 / 370
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].
199 / 370
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.
200 / 370
Zeitanalyse
Sei T (n) die Gesamtzahl der Vergleiche. Wir erhalten folgende
Rekursionsgleichung für T (n):
n
7n
+T
T (n) ≤ T
+ O(n)
5
10
Aus dem Mastertheorem II folgt damit T (n) ∈ O(n).
201 / 370
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
= 10
erhalten
Es ergibt sich, dass damit T (n) ≤ 16n gilt: mit 15 + 10
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.
202 / 370
Quickselect
Algorithmus 10.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
203 / 370
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}.
”
204 / 370
Durchschnittsanalyse von Quickselect
Unterscheide 3 Fälle:
1. Fall: i < j ≤ k.
E [Xij ] =
Pr[ i oder j wird als erstes im Intervall [i , . . . , k] gezogen“]
”
= k−i2+1
X X
X
k −i
E [Xij ] = 2
k −i +1
1≤i <k i <j≤k
1≤i <k
X
1
=2
1−
k −i +1
1≤i <k
= 2(k − H(k))
wobei H(k) ∈ Θ(ln k) die harmonische Funktion ist.
2
und
2. Fall: k ≤ i < j, analog folgt E [Xij ] = j−k+1
X X
E [Xij ] = 2(n − k + 1 − H(n − k + 1))
k<j≤n k≤i <j
205 / 370
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).
206 / 370
Durchschnittsanalyse von Quickselect
3. Fall: i < k < j.
E [Xij ] = j−i2+1
X
X
E [Xij ] = 2
1≤i <k k<j≤n
X
X
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
207 / 370
Durchschnittsanalyse von Quickselect
◮
◮
◮
◮
1. Fall + 2. Fall zusammen ergeben < 2n
Mit kn ≤2n ergibt sich:
n ≤ 2(1 + ln(2))n
Q(n) < 2 n + ln k−1
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.
208 / 370
14. Vorlesung, 02.12.2013
1. Quicksort: Durchschnittsanalyse
2. Median aus Drei
209 / 370
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.
210 / 370
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.
211 / 370
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
212 / 370
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.
213 / 370
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
214 / 370
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
215 / 370
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.
216 / 370
Quicksort: Durchschnittsanalyse
Beweis: Wie bei Quickselect werden auch bei Quicksort i und j
maximal einmal verglichen. Falls sie verglichen werden ist dann i oder
j aktuelles Pivotelement. Setze also wieder
Xij (π) := i wird mit j verglichen“ ∈ {0, 1}.
”
Im Unterschied zu Quickselect gilt für alle i < j stets:
◮
◮
E [Xij ] =
2
j−i +1
217 / 370
Quicksort: Durchschnittsanalyse
Daher
Q(n) =
X
i <j
E [Xij ] =
X
i <j
n−1 n−d
XX 2
2
=
.
j −i +1
d +1
d=1 i =1
n−1
Q(n) X n − (d + 1) + 1
=
2
d +1
d=1
= −(n − 1) + (n + 1)
n−1
X
d=1
1
d +1
= (1 − n) + (n + 1)(H(n) − 1)
= (n + 1)H(n) − 2n.
218 / 370
Quicksort: Durchschnittsanalyse
Es gilt also bei zufälliger Pivot-Wahl:
Q(n) = 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 nach
Sedgewick 1,18n log n − 2,2n.
Dies ist im Mittel nur noch um 18% schlechter.
219 / 370
14. und 15. Vorlesung, 02./03.12.2013
Nächste Themen:
◮
Fibonacci-Heaps.
◮
Amortisierte Zeitanalyse.
Anwendungen:
◮
Dijkstra, Prim.
◮
Berechnung minimaler Schnitte nach Stoer/Wagner.
220 / 370
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 )
221 / 370
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.
222 / 370
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.
223 / 370
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).
224 / 370
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)).
225 / 370
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.
226 / 370
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!)
227 / 370
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.
228 / 370
decrease key
Definition 13.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).
229 / 370
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.
230 / 370
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.
231 / 370
Fibonacci-Zahlen

√ !k
1  1+ 5
Fk = √
−
2
5
Die Fibonacci-Zahlen wachsen exponentiell.
Also rmax (n) ∈ O(log n).

√ !k
1− 5 
2
232 / 370
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.
233 / 370
Amortisierte Zeiten
Für die weitere Analyse einer Sequenz von Operationen betrachten wir
die gegen eine Potentialfunktion amortisierte Zeit.
Definition 13.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 ) .
234 / 370
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.
235 / 370
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.
236 / 370
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) .
237 / 370
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).
238 / 370
delete min
Satz 13.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)
239 / 370
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.
240 / 370
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.
241 / 370
16. Vorlesung, 09.12.2013
1.) Verwaltung von Mengen: Union-Find
2.) Kruskal-Algorithmus zur Berechung minimal spannander Bäume
3.) Äquivalenztest für DFA
242 / 370
Verwaltung von Mengen
Union-Find–Algorithmen
Definition: Eine Partition P einer Menge M ist eine Zerlegung von M
in disjunkte, nicht-leere Teilmengen:
m
M =
[
˙
Pi
i =1
P = {Pi | Pi ∩ Pj = ∅, Pi 6= ∅, 1 ≤ i < j ≤ m}
Beispiel: Sei M = {1, 2, . . . , 12}. Dann ist P = {Q, R, S} mit
Q = {i ∈ M | i ungerade}, R = {i ∈ M | i ≡ 0 mod 4} und
S = {i ∈ M | i ≡ 2 mod 4} eine Partition von M.
243 / 370
Union-Find
◮
◮
Find ist eine Funktion von M nach P, die jedem i ∈ M die
Menge Pj zuordnet, für die i ∈ Pj gilt.
Union verändert die Partition wie folgt: Union(A, B, C ) bedeutet,
dass die Partitionselemente A, B ∈ P zu einer neuen Menge mit
dem Namen C vereinigt werden. Nach Union(A, B, C ) ist die
neue Partition (P \ {A, B}) ∪ {A ∪ B}, wobei das Element A ∪ B
nun C heißt.
244 / 370
Feld von Paaren
1
Q
2
S
3
Q
4
R
5
Q
6
S
7
Q
8
R
9
Q
10
S
11
Q
12
R
Hier gilt z.B. Find(5) = Q und Union(Q, R, T ) ergibt:
1
T
2
S
3
T
4
T
5
T
6
S
7
T
8
T
9
T
10
S
11
T
12
T
245 / 370
Feld: Quadratische Kosten
◮
◮
◮
◮
Kosten: Find–Operation O(1).
Kosten: Union–Operation O(n).
In den Anwendungen werden häufig m Union-Find–Operationen
hintereinander durchgeführt, mit m ∈ Θ(n).
Damit insgesamt: O(n2 ).
246 / 370
Knotenbeschriftete Wälder
Jede Klasse ist ein Baum. Die Partition wird also durch einen Wald
definiert.
Der Name der Klasse ist der Name der Wurzel.
Wir werden sehen, dass bei einer n-elementigen Grundmenge die Höhe
eines jeden Baums durch log(n) beschränkt ist. Somit kosten in dieser
Realisierung Find-Operationen O(log(n)) Zeit, während Union in
konstanter Zeit durchgeführt werden kann.
Eine weitere Idee zur Verkürzung der Suchpfade besteht darin, bei
einem Aufruf von Find alle Knoten auf dem Pfad, den man zur Wurzel
hin durchläuft, direkt unter die Wurzel anzuhängen.
247 / 370
Union
Die Initialisierung ist dann:
name(vi ) := i
root(i ) := vi
pred(vi ) := nil
count(vi ) := 1
Die Union-Operation Union(i , j) wird dann so realisiert, dass der
kleinere der beiden Bäume i , j an die Wurzel des größeren angehängt
wird:
248 / 370
Find–Implementierung mit Pfadverkürzung
Algorithmus 14.1
function Find(i : Element): Element;
var u, v , root: Knoten;
begin
u := element[i ];
while pred(u) 6= nil do u := pred(u);
endwhile
root := u; u := element[i ];
while pred(u) 6= nil do v := pred(u); pred(u) := root; u := v
endwhile
return name(root);
endfunction
249 / 370
Find mit Pfadverkürzung
p
p
s
q
q
r
r
s
Baum nach Find(s)
Baum vor Find(s)
250 / 370
Der Rang eines Knotens
Definition 14.1
Der Rang eines Knotens v , Rang(v ), ist die Höhe des Knotens in dem
Wald, der ohne Pfadverkürzung erzeugt wurde.
Lemma. Sei v ein Knoten mit Rang(v ) = r . Dann hat der Teilbaum
mit der Wurzel v mindestens 2r Elemente.
Beweis:
Für r = 0 ist die Behauptung klar.
Betrachte den Zeitpunkt, in dem v den Rang r (v ) = r erhält. Dann
hat v ein Kind v ′ und im Teilbaum von v ′ sind 2r −1 Elemente, vorher
waren im Teilbaum von v bereits 2r −1 Elemente, also hat der
Teilbaum von v jetzt 2 · 2r −1 = 2r Elemente.
Zwei Knoten mit gleichem Rang sind nicht Vorgänger voneinander.
Damit folgt:
Korollar 14.2
Es gibt höchstens n/2r Knoten mit Rang r .
251 / 370
Zeitanalyse für Union-Find
Dieser Abschnitt beschreibt die Analyse nach Robert E. Tarjan (1983)
für m Union-Find-Operationen.
Wir verwenden die folgende Ackermannfunktion:
A0 (r ) = r + 1,
Ak+1 (r ) = Ark (r ).
(Hierbei bezeichnet Ark (r ) die r -fache Anwendung von Ak auf r )
Es ist Ak (1) = 2; daher ist sinnvall:
α(n) = min{k | Ak (2) > n}.
A1 (x) = 2x, A2 (x) = x2x , A3 (2) = 2048, also
A4 (2) = A23 (2) = A3 (2048) = A2048
(2048): ein Turm von mehr als
2
2000 Potenzen der 2. Daher ist α(n) ≤ 4 = α(2048) für alle
denkbaren Werte.
252 / 370
Analyse von m Union-Find-Operationen
Wir betrachten n Knoten und die folgende zeitabhängige Funktion
part (x):
Definition 14.3
Sei x ein Knoten mit Rang r . Dann bezeichnet part (x) seinen
Vorgänger (englisch: parent) zum Zeitpunkt t.
Definition 14.4
Ein Knoten x mit Rang r ≥ 2 gehört im Zeitabschnitt t zur Klasse k,
falls k maximal ist mit
r (part (x)) ≥ Ak (r (x)).
253 / 370
Analyse von m Union-Find-Operationen
◮
Wurzeln oder Knoten vom Rang 0 oder 1 gehören in keine Klasse.
Ein innerer Knoten mit Rang 2 gehört mindestens in die Klasse 0.
◮
Es gibt höchstens α(n) verschiedene Klassen.
◮
Realistisch: nur die Klassen 0, 1, 2 und 3.
◮
Eine Klasse kann als Maß für den Abstand eines Knotens zu
seinem Vaterknoten angesehen werden. Damit ist auch klar: Die
Klassennummern, die man auf dem Pfad zur Wurzel antrifft,
müssen nicht wie die Ränge monoton steigen.
254 / 370
Die Lebensgeschichte eines Knotens
◮
Ein Knoten x beginnt als Wurzel.
◮
Wenn er den Wurzelstatus verliert, erhält er seinen Rang r (x).
◮
Bei Rang 0 oder 1, bleibt x für immer klassenlos.
◮
Bei Rang 2 oder mehr betritt x eine Klasse k ≥ 0.
◮
◮
Ab jetzt geht es in der Klassengesellschaft nur aufwärts.
Realistischer Weise sollte man nur auf Klasse 3 hoffen.
255 / 370
Analyse von m Union-Find-Operationen
Erinnerung: Teuer sind nur die Find-Operationen.
Bei einem Find(i ) verteilen wir auf dem Pfad Gold- und Eisenstücke
auf die Knoten. Wir unterscheiden α(n) Klassen von Eisenstücken, so
dass es insgesamt 1 + α(n) verschiedene Währungen gibt.
Goldverteilung: Wenn x auf dem Pfad zur Wurzel besucht wird, gibt
es ein Goldstück, falls
x keiner Klasse angehört (d.h. x ist Wurzel oder vom Rang 0 oder 1)
oder x letzter seiner Klasse ist.
Korollar 14.5
Insgesamt werden nicht mehr als (3 + α(n))m Goldstücke verteilt.
256 / 370
Analyse von m Union-Find-Operationen
Eisenverteilung: Wenn x zur Zeit t auf dem Pfad zur Wurzel besucht
wird, erhält x ein Eisenstück der Klasse k, falls x zu dieser Zeit zur
Klasse k gehört und nicht letzter seiner Klasse ist.
Beobachtung: Erhält x zur Zeit t ein Eisenstück der Klasse k, so
gibt es auf dem Pfad zur Wurzel Knoten x, part (x), y , part (y ) mit:
Ak (r (x)) ≤ r (part (x)) ≤ r (y )
und
Ak (r (y )) ≤ r (part (y )).
Satz 14.6
Sei i ≥ 1 mit r (part (x)) ≥ Aik (r (x)). Dann gilt zur Zeit t + 1 die
Beziehung:
r (part+1 (x)) ≥ Aik+1 (r (x)).
257 / 370
Beweis
Wähle auf dem Pfad x, part (x), y , part (y ) mit:
Aik (r (x)) ≤ r (part (x)) ≤ r (y ), Ak (r (y )) ≤ r (part (y )).
Dann folgt:
r (part+1 (x)) ≥
≥
≥
≥
=
r (part (y ))
Ak (r (y ))
Ak (r (part (x)))
Ak (Aik (r (x)))
Aik+1 (r (x)).
258 / 370
Korollare
Ein Knoten vom Rang r erhält maximal r Eisenstücke der Klasse k.
Beweis: Nach r Find-Operationen in der Klasse k gilt:
r (pars (x)) ≥ Ark (r ) = Ak+1 (r )
und der Knoten steigt in die Klasse k + 1 auf.
Korollar 14.7
Es werden insgesamt maximal 3n
2 ≤ 2n Eisenstücke der Klasse k
verteilt.
Beweis: Es gibt höchstens n/2r Knoten mit Rang r und jeder erhält
höchstens r Eisenstücke der Klasse k. Damit:
X rn
3n
=
r
2
2
r ≥2
Korollar 14.8
Es werden insgesamt maximal 2α(n)n Eisenstücke verteilt.
Beweis: α(n) Klassen und pro Klasse 2n Eisenstücke.
259 / 370
Abschätzung für die Gesamtkosten
Alle Finds zusammen kosten O 3m + α(n)(2n + m) Zeit.
Beweis:
(3 + α(n))m Gold + 2α(n)n Eisen.
Übung: Für α(n) < 4 dominiert die Konstante 6m im O-Term, da
m > n. Wie erreicht man 5m?
260 / 370
Minimale Aufspannende Bäume
Definition 14.9
Ein Graph G = (V , E ) heißt zusammenhängend, wenn je zwei Knoten
durch einen Pfad verbunden sind.
Definition 14.10
Ein Baum ist ein zusammenhängender, kreisfreier, ungerichteter
Graph.
Bemerkung 14.11
Jeder Baum mit n Knoten besitzt genau n − 1 Kanten.
Definition 14.12
Ein minimaler aufspannender Baum (minimal spanning tree, MSB) zu
einem gewichteten Graphen G = (V , E , γ) ist ein Baum
B = (V , P
F , γ|F ) mit F ⊆ E mit minimalem Gewicht
γ(B) := e∈F γ(e).
261 / 370
Algorithmus 14.2 Kruskal–Algorithmus zur Bestimmung des MSB
function kruskal(G = (V , E , γ): kantengew. Graph): Kantenmenge;
(∗ G sei zusammenhängend ∗)
(∗ E = {e1 , e2 , . . . , em } sei nach Gewichten aufsteigend sortiert. ∗)
var m, i : integer;
x, y : Knoten;
T : Kantenmenge;
(∗ des MSB ∗)
begin
m := |E |; T := ∅;
forall v ∈ V do [v ] := {v } endfor;
for i := 1 to m do
xy := ei ;
if Find(x) 6= Find(y ) then
Union([x] , [y ]); T := T ∪ {xy }
endif
endfor return T endfunction
262 / 370
Äquivalenz endlicher Automaten
Definition 14.13
Ein endlicher, deterministischer Automat über dem Alphabet Σ ist ein
5-Tupel A = (Q, Σ, δ, q0 , F ) mit:
◮
Q = Zustände,
◮
q0 ∈ Q = ist Startzustand,
◮
◮
δ : Q × Σ −→ Q = Übergangsfunktion,
F ⊆ Q = Endzustände.
263 / 370
Äquivalenz endlicher Automaten
Schreibe statt δ(q, w ) für q ∈ Q und w ∈ Σ∗ , vereinfacht qw .
L(A) := {w ∈ Σ∗ | q0 w ∈ F }
L(q) := {w ∈ Σ∗ | qw ∈ F }.
Gegeben: A = (Q, Σ, δ, q0 , F ) und A′ = (Q ′ , Σ, δ′ , q0′ , F ′ ).
Frage: L(A) = L(A′ )?
264 / 370
Äquivalenztest DEA
Q̃ := disjunkte Vereinigung von Q und Q ′
R ⊆ Q̃ × Q̃ die kleinste Äquivalenzrelation mit den Eigenschaften:
1. (q0 , q0′ ) ∈ R,
2. (q, q ′ ) ∈ R, a ∈ Σ, q ∈ Q, q ′ ∈ Q ′ =⇒ (qa, q ′ a) ∈ R
Lemma: Es gilt: L(A) = L(A′ ) gdw.
R ∩ (F × (Q ′ \ F ′ )) ∪ ((Q \ F ) × F ′ ) = ∅.
265 / 370
Äquivalenztest DEA
Algorithmus 14.3
function Äquivalenztest-DFA(A, A′ : DFA) : boolean
begin
L := {(q0 , q0′ )};
while L 6= ∅ do
wähle ein (q, q ′ ) ∈ L;
L := L \ {(q, q ′ )}
if Find(q) 6= Find(q ′ ) then
if (q, q ′ ) ∈ [(F × (Q ′ \ F ′ )) ∪ ((Q \ F ) × F ′ )] then
return false
(∗ L(q0 ) 6= L(q0′ ) ∗)
else
Union(q, q ′ );
forall a ∈ Σ do
L := L ∪ {(qa, q ′ a)} endfor endif endif endwhile
return true endfunction
266 / 370
Zeitanalyse
Terminierung
Es sind maximal |Q| + |Q ′ | =: n = |Q̃| Union-Operationen möglich.
Damit werden maximal |Σ| · n Elemente zu L hinzugefügt. In jedem
Schleifendurchlauf wird ein Element aus L entfernt. Daher ergibt sich
die Termination nach maximal |Σ| · n Schleifendurchläufen.
|Q| + |Q ′ | =: n = |Q̃| Union–Operationen
|Σ| · n Find–Operationen
267 / 370
Teil 2: Berechenbarkeit
268 / 370
Aufgabe aus der Scheinklausur 2014
Seien α > 1 und k ∈ N so gewählt, dass 0 ≤ p(n) ≤ nk , 0 < t(0) und
t(n) = αt(n − 1) + p(n) für alle n ≥ 1. Dann gilt
t(n) ∈ Θ(αn ).
Lösung:
Schreibe t(n) = f (n)αn für eine Funktion f (n) > 0. Für n ≥ 1 gilt:
t(n) = f (n)αn = αf (n − 1)αn−1 + p(n).
f (n) = f (n − 1) + p(n)/αn ≥ t(0).
Also gilt t(n) ∈ Ω(αn ).
Wegen α > 1 folgt ferner
f (n) ≤
X
i ≥0
i k /αi ∈ O(1).
Dies zeigt t(n) ∈ O(αn ). Zusammen erhalten wir t(n) ∈ Θ(αn ).
269 / 370
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).
270 / 370
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)
271 / 370
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).
272 / 370
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 .
273 / 370
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.
[
3. Es sei ⊢M =
⊢d .
d∈δ
4. Mit Accept bezeichnen wir die Menge der akzeptierenden
Konfigurationen (aktueller Zustand ist aus F ⊆ Q).
5. Beachte: α ⊢M β ⇒ |α| − |β| ∈ {−1, 0, 1}
274 / 370
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
275 / 370
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.
276 / 370
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.
277 / 370
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)) betrachten.
Dies erlaubt, eine Position i ∈ {1, . . . , n} im Eingabestring auf einem
Arbeitsband abzuspeichern.
278 / 370
Wichtige Komplexitätsklassen
Gebräuchlichen Abkürzungen:
L = DSPACE(log(n))
(1)
NL = NSPACE(log(n))
[
P =
DTIME(nk )
(2)
(3)
NP =
(4)
k≥1
[
NTIME(nk )
k≥1
PSPACE =
[
k≥1
DSPACE(nk ) =
[
NSPACE(nk )
(5)
k≥1
Die Gleichung = in (5) ist als Satz von Savitch bekannt (kommt
noch).
279 / 370
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
k≥1 NSPACE(log (n))
NL
?
L
6=
Es gibt noch viele weitere Komplexitätsklassen: Besuchen Sie doch
den complexity zoo
(http://qwiki.caltech.edu/wiki/Complexity Zoo)
280 / 370
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.
281 / 370
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.
282 / 370
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.
283 / 370
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 ).
284 / 370
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:
◮
◮
◮
Selbstanwendung: Hs = { hMi ∈ { 0, 1 }∗ | hMi ∈ L(M) }
Spezielles Halteproblem: H0 = { hMi ∈ { 0, 1 }∗ | ε ∈ L(M) }
Nichtleerheit: H = { hMi ∈ { 0, 1 }∗ | L(M) 6= ∅ }
285 / 370
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) = Σ∗ }
286 / 370
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 L(M0 ) = ∅
und
¬P(L(M0 )) = P(L(M1 )) = b ∈ { true, false } .
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 ).
287 / 370
Beweisfortsetzung
Es gilt
ε ∈ L(M) ⇐⇒ L(M ′ ) 6= ∅ ⇐⇒ L(M ′ ) = L(M1 ) ⇐⇒ P(L(M ′ )) = b
Also
H0 = { hMi ∈ { 0, 1 }∗ | ε ∈ L(M) } ≤
M ′ ∈ { 0, 1 }∗ P(L(M ′ )) = b
288 / 370
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.
289 / 370
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)
290 / 370
Das Hilbertprogramm und der Gödel’sche
Unvollständigkeitssatz
291 / 370
Hintergrund
David Hilbert (23. Januar 1862 in Königsberg — 14. Februar 1943 in
Göttingen)
◮
1900: Hilbert stellt auf dem Zweiten Internationalen
Mathematikerkongress in Paris 23 zentrale Probleme der
Mathematik vor.
◮
1920: Aus den ersten beiden entwickelt er das
“Hilbertprogramm”:
Man beweise die Widerspruchsfreiheit der Mathematik.
292 / 370
Der Weg des Hilbertprogramms
Kurt Gödel (28. April 1906 in Brünn, Österreich-Ungarn, heute
Tschechien; – 14. Januar 1978 in Princeton, New Jersey)
◮ 1931: In “Über formal unentscheidbare Sätze der Principia
mathematica und verwandter Systeme” zeigt Gödel, dass das
“Hilbertprogramm” nicht durchführbar ist. Grundlage ist
◮ der Gödel’sche Unvollständigkeitssatz: Zu jedem formalen
Beweissystem B für die elementare Theorie der Arithmetik über
den natürlichen Zahlen gibt es effektiv eine wahre Aussage, die
sich in B nicht herleiten lässt.
Die elementare Theorie der Arithmetik über den natürlichen
Zahlen ist nicht aufzählbar.
◮ 1948: Alfred Tarski zeigt, dass die elementare Theorie der
Arithmetik über den reellen Zahlen entscheidbar ist. (Dies liegt
am Mittelwertsatz und dem daraus folgenden Satz von Rolle.)
◮ 1970: Yuri Matiyasevich (geb. 2.3.47) löste mit 22 Jahren das
10. Hilbert Problem “negativ”: Die Menge der Polynome in
mehreren Variablen und Koeffizienten in Z, die eine ganzzahlige
Lösung haben, ist unentscheidbar.
293 / 370
Formale Semantik
Die imperative Programmiersprache IMP:
Rechnungen von Turingmaschinen können in IMP beschrieben werden
und umgekehrt.
Die Sprache IMP verfügt über drei Arten syntaktischer Konstrukte.
◮
Arithmetische Ausdrücke
(Aexp)
◮
Boolesche Ausdrücke
(Bexp)
◮
Anweisungen bzw. Programme
(Cmd)
294 / 370
Aexp
Syntaktische Definition:
a ::= n | X | (a1 + a2 ) | (a1 − a2 ) | (a1 · a2 )
Dabei ist n ∈ N, X eine Programmvariable, a1 , a2 ∈ Aexp. 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.
295 / 370
Bexp
Syntaktische Definition:
b ::= true | a1 < a2 | ¬b | b1 ∧ b2
Dabei seien a1 , a2 ∈ Aexp, b, b1 , b2 ∈ Bexp.
296 / 370
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.
Semantik: Einem gegebenen Programm c ∈ Cmd und einem
Speicherzustand σ ∈ Σ wird ein neuer Speicherzustand σ ′ ∈ Σ
zugeordnet:
Cmd × Σ →p Σ
(Das p am Pfeil steht für partiell“).
”
297 / 370
Beispiel
Es sei c ∈ Cmd wie folgt definiert.
X2 := 1;
while X1 > 1 do
X2 := X2 · X1 ;
X1 := X1 − 1
od
Speicherzustände werden durch Zahlenpaare definiert, da nur X1 und
X2 vorkommen, Σ = N{ X1 ,X2 } = N2 = N × N.
Die Semantikfunktion von c ist total definiert, da das Programm
immer terminiert. Es gilt (0, k) 7→ (0, 1) = (0, 0!) und (n, k) 7→ (n, n!)
für n ≥ 1. Das Programm berechnet daher die Fakultätsfunktion.
298 / 370
Prädikatenlogik der 1. Stufe über N
Syntaktische Definition von Assn, der Menge der arithmetischen
Formeln :
A ::= b | ∃X : A | ¬A | A1 ∧ A2
Dabei ist b ∈ Bexp, X eine Variable, A1 , A2 ∈ Assn.
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 elementare Theorie über N ist die folgende Teilmenge von Assn:
Th(N) = { F ∈ Assn | F ist ein gültiger Satz } .
299 / 370
Der Gödel’sche Unvollständigkeitssatz nach Turing
Satz 16.7 (Gödel’scher Satz aus Sicht von Turing)
Die elementare Theorie über N ist nicht aufzählbar. Die folgende
Sprache ist also weder aufzählbar noch ist ihr Komplement aufzählbar.
Th(N) = { hF i ∈ { 0, 1 }∗ | F ∈ Assn ∧ F ist ein gültiger Satz }
Proof.
Idee: Für jeden Satz in F ∈ Assn gilt entweder hF i ∈ Th(N) oder
h¬F i ∈ Th(N) (aber nicht beides). Wäre Th(N) aufzählbar, dann
auch entscheidbar. Dies kann jedoch nicht sein:
Zu einer Turingmaschine M konstruieren wir eine Formel FM in zwei
freien Variablen X , Y mit der Eigenschaft:
ε ∈ L(M) ⇐⇒ ∃Y : FM (0, Y ) ⇐⇒ FM (0, 1)
Dies zeigt dann { hMi ∈ { 0, 1 }∗ | ε ∈ L(M) } ≤ Th(N).
300 / 370
Das Gödelsche β–Prädikat
Lemma 5.2.3 Das Prädikat β : N4 → B sei definiert durch
β(a, b, i , n) ⇔ n = a mod (1 + b(i + 1)).
Seien t, n0 , . . . , nt ∈ N. Dann gibt es Zahlen a, b ∈ N so, dass für alle
i ∈ {0, . . . , t} und alle n ∈ N gilt:
β(a, b, i , n) ⇔ n = ni .
Beweis: Wähle b ∈ N mit t! | b und b ≥ max{n0 , . . . , nt }. Etwa:
b = max{t, n0 , . . . , nt }!
Zeige: ggT(1 + b(i + 1), 1 + b(j + 1)) = 1 (für 0 ≤ i < j ≤ t). Mit
dem Chinesischen Restsatz folgt die Existenz einer Zahl n, für die
n = ni mod (1 + b(i + 1)) für i ∈ {0, . . . , t} gilt.
301 / 370
Der Gödel’sche Unvollständigkeitssatz
Satz 16.8 (Gödel, 1931)
Zu jedem formalen Beweissystem B für elementare Theorie über N
existiert effektiv eine wahre Formel, die in B nicht beweisbar ist.
Ein (formales) Beweissystem B für einen Teilmenge A ⊆ { 0, 1 }∗ ist
eine entscheidbare Sprache B ⊆ { 0, 1 }∗ zusammen mit einer totalen
und berechenbaren Funktion b : B → A. Sei jetzt B = (B, b)
Beweissystem für Th(N). Wir zeigen, dass wir effektiv einen wahren
Satz F ∈ Th(N) konstruieren können, der nicht im Bild von b ist.
Damit kann B nicht alle wahren Sätze herleiten.
Wir schreiben, ⊢ F , falls F im Bild b(B) liegt. Beachte, ⊢ F impliziert
F ∈ Th(N) nach Definition eines Beweissystems.
302 / 370
Zunächst beachten wir, dass Assn und auch die Teilmenge der
arithmetischen Formeln mit einer freien Variablen Assn1 aufzählbar
ist. Zu F (X ) ∈ Assn1 finden wir also effektiv ein G ∈ N (ihre
Gödelnummer) mit F (X ) = FG (X ).
Assn1 = { F0 (X ), F1 (X ), F2 (X ), . . . } .
Beispielsweise könnte F42 (X ) die Formel ∃Y : 6 · Y = X sein. Dann
gilt etwa F42 (42) ∈ Th(N) und F42 (43) ∈
/ Th(N).
Die Menge
{ G ∈ N | ⊢ FG (G ) }
aufzählbar und kann durch ein IMP-Programm berechnet werden.
Es gibt daher effektiv ein c ∈ Cmd und eine arithmetische Formel
Fc (X , Y mit
Fc (G , 1) ⇐⇒ ⊢ FG (G ).
Wir finden ein U ∈ N und FU (X ) ∈ Assn1 mit
FU (X ) = Fc (X , 1).
303 / 370
Der nächste Schritt ist Diagonalisierung. Wir betrachten D ∈ N mit
FD (X ) = ¬FU (X ) ∈ Assn1 und überlegen, ob FD (D) gilt.
Angenommen, FD (D) ist falsch. Dann gilt FU (D) = Fc (D, 1) und
⊢ FD (D). Das Beweissystem liefert eine falsche Aussage her und ist
daher nicht korrekt. Dies ist widerspricht der Definition von
Beweissystemen.
Also ist FD (D) wahr! Damit ist FU (D) falsch und damit auch nicht
⊢ FD (D). Das Beweissystem ist also nicht vollständig, da es die wahre
Aussage FD (D) nicht herleiten kann.
Umgangssprachlich ist FD (D) die Aussage
Ich bin nicht beweisbar.
304 / 370
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)
✲
ML′
✲ ja
✲ nein
ML
305 / 370
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·ℓ
306 / 370
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.
307 / 370
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} :
(x,v )∈E F (x, v ) =
(v ,y )∈E F (v , y )
(Flußerhaltung)
◮ ∀e ∈ E : F (e) ≤ c(e).
308 / 370
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 .
309 / 370
Beispiel für Polynomialzeitreduktion
Sei G = (A, B, E ) ein bipartiter Graph:
A
B
310 / 370
Beispiel für Polynomialzeitreduktion
Füge eine Quelle s und eine Senke t an:
A
s
B
t
311 / 370
Beispiel für Polynomialzeitreduktion
Berechne einen maximalen Fluß:
A
s
B
t
312 / 370
Beispiel für Polynomialzeitreduktion
Hieraus ergibt sich die Lösung des Matchingproblems:
A
B
313 / 370
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.
314 / 370
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.
315 / 370
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.
316 / 370
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.
317 / 370
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.
318 / 370
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.
319 / 370
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)
320 / 370
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.
321 / 370
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.
322 / 370
Teil 4: NP-Vollständigkeit
323 / 370
Generische NP-Vollständigkeit
Sei hw , Mi eine Codierung eines Wortes w ∈ Σ∗ und einer
nichtdeterministischen Turingmaschine M.
LGen = {hw , Mi $m |w ∈ Σ∗ , M nichtdeterministische Turingmaschine,
m ∈ N, M hat bei Eingabe w eine akzeptierende
Berechnung der Länge ≤ m}
Satz 17.3
LGen ist NP-vollständig.
Beweis:
LGen ∈ NP:
Für eine Eingabe hw , Mi $m simuliere M bei Eingabe w
nichtdeterministisch für maximal m Schritte.
Dies ist ein nichtdeterministischer Polynomialzeitalgorithmus für LGen .
324 / 370
Generische NP-Vollständigkeit
LGen ist NP-schwierig:
Sei L ∈ NP beliebig und M eine nk -zeitbeschränkte
nichtdeterministische Turingmaschine mit L = L(M) (k ist eine
Konstante).
Die Reduktion von L auf LGen berechnet nun in logarithmischem Platz
auf eine Eingabe w ∈ Σ∗ die Ausgabe
k
f (w ) = w , M $n .
Es gilt: w ∈ L(M) ⇐⇒ f (w ) ∈ LGen .
325 / 370
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.
326 / 370
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.
327 / 370
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.
328 / 370
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.
329 / 370
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.
330 / 370
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 ]) ∈ ∆.
331 / 370
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
b
i
q
i+1
a
b
a′
p
···
···
···
···
332 / 370
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.
333 / 370
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)).
334 / 370
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.
335 / 370
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.
336 / 370
P Vollständigkeit von HORNSAT
Aus dem Beweis ergibt sich unmittelbar:
HORNSAT ist P-vollständig.
337 / 370
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.
338 / 370
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.
339 / 370
SAT ∩ KNF ist NP-vollständig
Satz 17.4
SAT ∩ KNF ist NP-vollständig.
Beweis: Siehe Beweis von Cook/Levin.
340 / 370
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:
341 / 370
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
′
=
^
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 .
342 / 370
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
343 / 370
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!
344 / 370
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.)
345 / 370
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
346 / 370
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 ).
347 / 370
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.
348 / 370
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.
349 / 370
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
350 / 370
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
351 / 370
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.
352 / 370
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.
353 / 370
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).
354 / 370
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
355 / 370
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 4
ejl 2
ejl 3
356 / 370
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 ):
357 / 370
′′
ek4
′′
ek3
′′
ek2
a34
a33
a32
G (ck )
b4
b3
a24
a31
′
ek4
′′
ek1
G (xk2 )
′
ek3
a23
′
ek2
a22
a21
a14
b2
a13
a12
ek3
ek4
′
ek1
G (xk1 )
b1
a11
ek2
ek1
G (xk3 )
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.
358 / 370
Hamilton-Kreis und Hamilton-Pfad sind NP-vollständig
Beispiel: Sei F = (x1 ∨ x2 ∨ x3 ) ∧ (x1 ∨ x2 ∨ x3 ).
{z
} |
{z
}
|
c1
c2
G (c2)
G (c1)
G (x1)
G (x2)
G (x3)
Dann ist G (F ) der folgende Graph:
359 / 370
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 ai 1 − ai 2 − ai 3 − ai 4 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.
360 / 370
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 .
361 / 370
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.
362 / 370
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 ).
363 / 370
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)).
364 / 370
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.
365 / 370
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)).
366 / 370
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
367 / 370
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
368 / 370
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 .
369 / 370
Varianten algorithmischer Probleme
Wieder gilt: (A) in Polynomialzeit lösbar =⇒ (C) in Polynomialzeit
lösbar.
Zeigen Sie dies als Übung.
370 / 370