Ausgew¨ahlte Randomisierte Algorithmen

Ausgewählte
Randomisierte Algorithmen
Hilfreiche Literatur:
• Motwani, Raghavan: Randomized Algorithms, Cambridge University Press, 1995.
• Mitzenmacher, Upfal: Probability and Computing, Cambridge University Press, 2005.
• Hromkovic: Design and Analysis of Randomized Algorithms: Introduction to Design Paradigms, Springer
2005.
• Kleinberg, Tardos: Algorithm Design, Addison Wesley,
2005.
1
Lineare Programme in linearer Zeit
Wir betrachten das folgende Problem: Es soll der Extrempunkt eines Polyhedrons bezüglich einer vorgegebenen Richtung (bzw. Zielfunktion) bestimmt werden. Dieses Problem
entspricht einem LP mit d Variablen und, sagen wir, m Nebenbedingungen (NB).
Natürlich kann man dieses Problem mit der Simplex- oder
Ellipsoidmethode erschlagen. Aber wenn die Anzahl der
Dimensionen sehr klein ist, wie es in geometrischen Anwendungen häufig der Fall ist, so gibt es auch andere, effizien
m
tere Methoden. Beispielsweise kann man alle d ≤ md
Basislösungen (= Schnittpunkte von jeweils d linear unabhängigen NB-Hyperebenen) aufzählen und dann diejenige
Basislösung ausgeben, die die Zielfunktion maximiert. Dieser Ansatz liefert eine Laufzeitschranke der Größenordnung
ungefähr md .
Wir präsentieren jetzt einen sehr eleganten randomisierten
Algorithmus von Seidel (1991), dessen erwartete Laufzeit
tatsächlich linear in m beschränkt ist.
2
Problembeschreibung:
Gebeben sei ein LP mit d Variablen x1 , . . . , xd , einer Zielfunktion der Form Maximiere cT x und insgesamt m NB der
Form Ax ≤ b. Gesucht ist eine zulässige Lösung des LPs, die
die Zielfunktion maximiert.
Wir treffen die folgenden Annahmen:
• Die optimale Lösung sei eindeutig. Diese Eigenschaft
kann man z.B. erzwingen wir, indem man die Zielfunktion virtuell perturbiert, d.h. zu ci den Wert i für > 0,
→ 0 hinzuaddiert.a
• Das LP sei zulässig, d.h. es gebe mindestens eine zulässige Lösung. Die Verallgemeinerung des Algorithmus für
möglicherweise unzulässige LPs lassen wir als Übungsaufgabe.
a Dies
bedeutet, dass wir im Fall mehrerer optimaler Lösungen die lexikographisch kleinste Basislösung auswählen.
3
Der Algorithmus von Seidel
Sei H die Menge der NB. Zu jeder NB in H können wir eine
Hyperebene assoziieren, die die Begrenzung des entsprechenden Halbraums festlegt. In etwas nachlässiger Schreibweise
unterscheiden wir im Folgenden nicht immer zwischen den
NB und ihren Hyperebenen und verwenden diese Begriffe
synonym.
Um sicherzustellen, dass das LP beschränkt ist und eine
endliche optimale Lösung hat, fügen wir dem LP zusätzlich
zu den NB in H sogenannte Box-Bedingungen der Form
−t ≤ xi ≤ t (1 ≤ i ≤ d)
für einen Wert t hinzu, der so groß gewählt ist, dass alle Basislösungen nur Variablenwerte echt kleiner als t annehmen.
Für jedes LP existiert eine solche Zahl t und sie kann in Zeit
polynomiell in der Eingabelänge des LPs berechnet werden.
Alternativ kann man t auch in Form eines symbolischen Wertes repräsentieren, der für eine Zahl steht, die größer ist als
alle anderen Zahlen, die während der Berechnung erzeugt
werden.
4
Der Algorithmus berechnet eine optimale Basislösung des LPs
durch rekursives Entfernen der NB aus H in einer zufälligen
Reihenfolge. Für jede Teilmenge H 0 ⊆ H, sei LP (H 0 ) das
LP, das wir erhalten, wenn wir alle NB aus H \ H 0 aus
dem gegebenen LP streichen. Die optimale Basislösung von
LP (H 0 ) wird mit opt(H 0 ) bezeichnet.
Wir beschreiben den Algorithmus zunächst im Pseudocode
und erläutern dann die Details.
Algorithmus SeideLP
1
2
3
4
falls d = 1 oder m = 1, so gib opt(H) aus;
sonst wähle uniform zufällig eine Bedingung h ∈ H,
und berechne opt(H \ {h}) rekursiv;
falls opt(H \ {h}) die Bedingung h nicht verletzt,
so gib opt(H \ {h}) aus;
sonst berechne den Schnitt des Lösungspolyhedrons
mit der Hyperebene h, und löse das so entstehende
(d−1)-dimensionale LP rekursiv.
5
Die Box-Bedingungen gehören nicht zur Menge H und
werden nicht durch den Algorithmus entfernt. Wenn das
eigentliche LP (ohne Box-Bedingungen) unbeschränkt ist,
können wir das an der Ausgabe des Algorithmus erkennen,
weil dann in der berechneten optimalen Lösung mindestens
eine Variable den Wert t oder −t hat.
Am Rekursionsende d = 1 gibt es nur noch eine Variable
und das LP kann in Zeit O(m) gelöst werden. Falls das
eigentliche LP ohne Box-Bedingungen unbeschränkt ist,
erhält diese Variable den Wert t oder −t, je nachdem ob sie
mit positivem oder negativem Vorzeichen in der Zielfunktion
vorkommt.
Am Rekursionsende m = 1 gibt es neben den Box-Bedingungen
nur noch eine weitere NB. Dieses Problem entspricht dem
relaxierten Rucksackproblem, das durch einen GreedyAlgorithmus in Zeit O(d log d) = O(d2 ) gelöst werden
kann.
6
In Schritt 4 wird der Schnitt des Lösungspolyhedrons mit
der Hyperebene h berechnet und dann das so entstehende
LP rekursiv gelöst. Dazu werden die folgenden Teilschritte
durchgeführt.
• Die NB h wird als Gleichung aufgefasst, und diese
Gleichung wird zu einer beliebigen Variable xk (k ∈
{1, . . . , d}) auflöst.
• Die Variable xk wird dann in der Zielfunktion und allen
NB aus H substituiert.
• Seien hk+ und hk− die Box-Bedingungen für xk . Auch
in diesen beiden Bedingungen substituieren wir xk .
• Wir setzen dann H 0 = H ∪ {hk+ , hk− } \ {h} und lösen
LP (H 0 ) rekursiv.
Beachte, LP (H 0 ) hat zwar m + 1 NB aber nur noch d − 1
Variablen, d.h. die Dimension des LPs hat sich um eins
verringert.
7
Korrektheit:
Die Terminierung des Algorithmus ist gesichert, weil sich
der Wert k(d, m) = 2d + m in jedem rekursiven Aufruf um
mindestens eins verringert und der Algorithmus spätestens für
k(d, m) = 5 terminiert, weil dann entweder m oder d den
Wert eins annehmen.
Warum findet der Algorithmus die optimale Lösung? – Entweder ist die zufällig ausgewählte NB h ∈ H eine derjenigen
NB, die sich an der optimalen Lösung schneiden, oder das
Entfernen von h hat keinen Einfluss auf die optimale Lösung
des LPs. Falls h nicht relevant für die optimale Lösung ist,
so gibt der Algorithmus die optimale Lösung opt(H \ {h})
in Schritt 3 aus. Falls h jedoch zu denjenigen NB gehört, die
sich an opt(H) schneiden, so wissen wir, dass sich opt(H)
auf der zu dieser NB gehörenden Hyperebene befindet und
der Algorithmus findet die optimale Lösung im rekursiven
Aufruf in Schritt 4.
8
Laufzeitanalyse:
Sei T (m, d) eine obere Schranke für die erwartete Laufzeit
von Algorithmus SeideLP.
Im Fall m > 0 und d > 1 kann die erwartete Laufzeit für
jeden der vier Schritte wie folgt abgeschätzt werden:
• Schritt 1: T1 = O(1)
• Schritt 2: T2 = T (m−1, d)
• Schritt 3: T3 = O(d)
• Schritt 4: T4 = T (m+1, d−1) + O(dm).
Schritt 4 wird jedoch nicht immer ausgeführt.
9
Lemma 1 Die Wkeit, dass Schritt 4 ausgeführt wird, ist
d
.
höchstens m
Beweis:
Sei x∗ = opt(H). Der Punkt x∗ befindet sich auf dem Schnitt
von mindestens d Hyperebenen, die entweder zu den NB in H
oder den Box-Bedingungen gehören. Sei D eine Auswahl von
genau d dieser Bedingungen mit der Eigenschaft, dass diese
Bedingungen die optimale Lösung festlegen, d.h. x∗ bleibt
auch dann optimal, wenn alle außer den Bedingungen in D
gestrichen werden.
Schritt 4 wird ausgeführt, wenn opt(H \ {h}) die NB h
verletzt. Dies passiert nur, wenn h eine der NB aus D ist. Die
NB h wird aber unifom zufällig aus H gewählt. Die Wkeit,
dass Schritt 4 ausgeführt wird, ist somit nach oben beschränkt
durch
|D ∩ H|
d
Pr [h ∈ D] =
≤
.
|H|
m
u
t
10
Insgesamt gilt im Fall m > 0 und d > 1 somit
d
T (m, d) ≤ T1 + T2 + T3 +
· T4 .
m
Unter Vernachlässigung konstanter Faktoren erhalten wir die
folgende Rekursionsgleichung:
Für m > 0 und d > 1 gilt
d
T (m, d) ≤ T (m−1, d) + d +
· T (m+1, d−1) .
m
2
Im Falle m = 0 oder d = 1 gilt
T (m, d) ≤ d2 + m .
Wir lösen nun die Rekursionsgleichung. Definiere dazu
f (d) = d f (d − 1) + 3d3 ,
für d > 1; und f (1) = 1. Es gilt
f (d) = d! +
d
X
k=2
weil
d!
= O(d!) ,
3k ·
(k − 1)!
3
Pd
3
3k
/(k − 1)! durch eine Konstante beschränkt ist.
k=2
11
Lemma 2 T (m, d) ≤ (m−1) · f (d) + 2d2 .
Beweis: Wir beweisen das Lemma per Induktion.
Induktionsanfang:
Für m = 1 gilt T (m, d) ≤ d2 + 1 ≤ (m−1) · f (d) + 2d2 .
Für d = 1 gilt T (m, d) ≤ m+1 = (m−1) · f (d) + 2d2 .
Induktionsschritt:
Sei nun m ≥ 2 und d ≥ 2. Setze k = 2d + m. Per Induktionsannahme gelte die Behauptung im Lemma für alle Tupel
(d0 , m0 ) mit 2d0 + m0 < k, also insbesondere für (m−1, d)
und (m+1, d−1). Es folgt
d
m
2
T (m, d) ≤ T (m−1, d) + d2 +
· T (m+1, d−1)
≤ (m−2) · f (d) + 3d +
d
m (m
3
· f (d−1) + 2d2 )
≤ (m−2)f (d) + 3d2 + 2d + d · f (d−1)
2
3
= (m−2)f (d) + 3d + 2d + d ·
f (d)−3d3
d
≤ (m−1) · f (d) + 2d2 .
u
t
12
Somit erhalten wir den folgenden Satz.
Satz 3 Algorithmus SeideLP löst ein zulässiges d-dimensionales
LP mit m Nebenbedingungen in erwarteter Zeit O(md!).
Damit können wir LPs mit kleiner Dimension sehr effizient
lösen. Wenn wir die Anzahl der Dimensionen als konstant
auffassen, so hat der Algorithmus eine lineare Laufzeit. Für
LPs mit einer zweistelligen Anzahl an Variablen ist dieses
Verfahren aber wohl nicht mehr zu empfehlen.
13
Randomisierte Suche nach dem Min-Cut
Gegeben sei ein Multigraph G = (V, E), d.h. ein Graph in
dem es mehrere Kanten zwischen zwei Knoten geben darf. Sei
n = |V |. Im Speicher repräsentieren wir den Multigraphen
durch eine Adjazenzmatrix mit Einträgen aus N0 , die angeben
wieviele Kanten zwischen den jeweiligen Knotenpaaren
verlaufen. Der Multigraph sei zusammenhängend.
Ein Schnitt bzw. Cut in G ist als eine Zerlegung der Knotenmenge V in zwei nicht-leere Teilmengen U und V \ U
definiert. Im Folgenden identifizieren wir den Schnitt mit der
Kantenmenge C = {{u, v} ∈ E | u ∈ U, v ∈ V \ U }, also mit
der Menge der Kanten zwischen diesen beiden Teilmengen.
Die Größe des Schnitts C entspricht der Kardinalität dieser
Kantenmenge. Ein Min-Cut ist ein Schnitt kleinstmöglicher
Größe.
Wir können einen Min-Cut durch Lösen von n − 1 Max-FlowProblemen berechnen (Übung). Wir werden zunächst einen
randomisierten Algorithmus von Karger (1993) beschreiben,
der einen Min-Cut in Zeit O(n4 ) berechnet, also zunächst
eigentlich nicht besser als der Max-Flow-Ansatz ist.
14
Die Kontraktion von Kanten:
Bei der Kontraktion einer Kante {u, v} werden
• die beiden Knoten u und v zu einem neuen Knoten w
zusammengezogen,
• u und v sowie alle Kanten zwischen u und v aus dem
Graphen entfernt, und
• jede Kante der Form {u, x} bzw. {v, x} durch eine Kante
der Form {w, x} ersetzt.
Eine Kontraktion kann in Zeit O(n) durchgeführt werden.
15
Algorithmus Contract(G)
1
2
3
4
5
H := G;
solange H mehr als zwei Knoten hat
wähle uniform zufällig eine der Kanten von H;
kontrahiere diese Kante;
sei C die Menge der überlebenden Kanten, gebe C aus.
Die Idee des Algorithmus ist einfach. Wir kontrahieren solange bis nur noch zwei Knoten übrigbleiben. Die Kanten
zwischen diesen zwei Knoten von H verbinden zwei Teilmengen der Knoten von G und sind somit ein Schnitt in G.
In anderen Worten, genau ein Schnitt überlebt die Kontraktionssequenz. Dieser Schnitt wird ausgegeben. Ein Min-Cut hat
dabei größere Chancen zu überleben als andere Schnitte, weil
er nur wenige Kanten enthält.
Die Laufzeit des Algorithmus ist O(n2 ). Wir werden zeigen,
dass dieser Schnitt mit Wkeit größer als
−1
n
2
=
= Θ(n−2 )
2
n(n − 1)
ein Min-Cut ist. Um konstante Erfolgswkeit zu erhalten,
werden wir den Algorithmus Θ(n2 ) mal wiederholen. Das
ergibt dann eine Laufzeit von O(n4 ).
16
Exkursion: Unabhängkeit von Zufallsereignissen:
Zwei Ereignisse E1 und E2 heißen unabhängig, falls gilt
Pr [E1 ∩ E2 ] = Pr [E1 ] · Pr [E2 ].
Für möglicherweise abhängige Ereignisse E1 und E2 gilt die
Formel Pr [E1 ∩ E2 ] = Pr [E1 ] · Pr [E2 |E1 ], wobei Pr [E2 |E1 ]
die bedingte Wkeit von E2 unter E1 ist.
Eine Kollektion von Ereignissen {Ei : i ∈ I} heißt unabhängig,
falls für alle Teilmengen S ⊆ I gilt
"
#
\
Y
Pr
Ei =
Pr [Ei ] .
i∈S
i∈S
Im allgemeinen Fall, also wenn E1 , E2 , . . . , Ek möglicherweise
abhängig sind, gilt
 
" k #
k
Y
\
\
i−1
Pr Ei Ei =
Pr
Ej  .
j=1
i=1
i=1
17
Satz 4 Pr [C ist ein Min-Cut von G] ≥
Beweis:
n −1
.
2
• Sei ei die i-te Kante, die kontrahiert wird (1 ≤ i ≤ n−2).
• Sei H0 = G und Hi der Graph H nach der i-ten Kontraktion.
• Sei K ein beliebiger Min-Cut von G.
Pr [C ist ein Min-Cut von G]
≥ Pr [C = K]


\
= Pr 
ei 6∈ K 
1≤i≤n−2

Y
\
=
Pr ei 6∈ K ei ∈
6 K .
1≤j<i
1≤i≤n−2

18
Lemma 5 Für 1 ≤ i ≤ n − 2 gilt,


\
2


Pr ei 6∈ K .
ej 6∈ K ≥ 1 −
n
−
i
+
1
1≤j<i
Beweis:
Sei k = |K|. Jeder Schnitt in Hj (0 ≤ j ≤ n − 2) ist auch ein
Schnitt in G. Deshalb ist der Min-Cut-Wert in Hj mindestens
so groß wie der Min-Cut-Wert in G, also mindestens k.
Sei nj die Anzahl der Knoten in Hj und mj die Anzahl der
k
Kanten. Die Wkeit für das Ereignis ei ∈ K ist mi−1
, weil alle
mi−1 Kanten in Hi−1 gleichwahrscheinlich sind.
Der Wert von mi−1 hängt irgendwie von dem Ereignis
T
1≤j<i ej 6∈ K ab. Aber es gilt immer mi−1 ≥ kni−1 /2,
denn ansonsten gäbe es einen Knoten mit Grad kleiner als k
und der Min-Cut-Wert von Hi−1 wäre, entgegen unserer obigen Feststellung, kleiner als k. Außerdem gilt ni−1 = n−i+1.
Wir fassen zusammen:


\
2
2
k

.
≤
=
Pr ei ∈ K ej 6∈ K  =
mi−1
ni−1
n−i+1
1≤j<i
u
t
19
Fortsetzung des Beweises von Satz 4:
Wir setzen das Lemma ein und erhalten
Pr [C ist ein Min-Cut von G]
Y 2
≥
1−
n−i+1
1≤i≤n−2
n−i−1
n−i+1
1≤i≤n−2
n−2
n−3
n−4
3
2
1
=
···
n
n−1
n−2
5
4
3
−1
n
2
,
=
=
2
n(n − 1)
=
Y
wobei sich die vorletzte Gleichung durch Kürzungen ergibt.
u
t
20
Wkeitsamplifikation:
• Um eine bessere Erfolgswkeit zu erhalten, wenden wir
den Contract-Algorithmus wiederholt an, und geben dann
den kleinsten Schnitt aus, den wir gefunden haben.
n
• Bei ( 2 · t)-facher Wiederholung des Algorithmus ist
die Wkeit den Min-Cut in allen Wiederholungen zu
verpassen höchstens
−1 !(n2 )·t t
1
n
,
≤
1−
e
2
wobei e = 2.718 . . . die Eulersche Konstante ist. Die
letzte Ungleichung folgt weil (1 − x1 )x ≤ 1e für jedes
x ≥ 1.
• Das bedeutet, auf Kosten der Laufzeit können wir die
Fehlerwkeit beliebig klein machen. Um eine konstante
n
Erfolgswkeit zu erhalten, reichen 2 Wiederholungen.
Das ergibt eine Gesamtlaufzeit von O(n4 ).
• Hat man einmal konstante Erfolgswkeit erreicht, kann
man die Fehlerwkeit sehr effizient reduzieren. Bemerkenswert ist, dass die Fehlerwkeit exponentiell in t sinkt.
Schon für t = 14 ist die Fehlerwkeit nur e−14 und damit
kleiner als 1 zu 1 Million.
21
Der folgende Algorithmus von Karger und Stein (1993)
berechnet in Zeit O(n2 log n) einen Schnitt, der mit Wkeit
Ω( log1 n ) ein Min-Cut ist.
Algorithmus Fastcut(G)
1. falls n ≤ 6 dann berechne einen Min-Cut durch
vollständiges Aufzählen und gebe ihn aus;
2. erzeuge zwei unabhängige Kontraktionssequenzen
√
der Länge n − t, wobei t := d1 + n/ 2e;
3. die dabei entstehenden Graphen mit jeweils t Knoten
nennen wir HA und HB ;
a) CA := fastcut(HA );
b) CB := fastcut(HB );
4. gib den kleineren der beiden Schnitte CA und CB aus.
22
Satz 6 Algorithmus Fastcut hat Laufzeit O(n2 log n).
Beweis:
Die Laufzeit ist durch die folgende Rekursionsgleichung nach
oben beschränkt:
n
+ O(n2 ) ,
T (n) = 2T
1+ √
2
falls n > 6, und T (n) = O(1), falls n ≤ 6.
Wir lösen diese Rekursionsgleichung zunächst recht grob und
verfeinern dann die einzelnen Argumente.
23
... grobe Laufzeitabschätzung ...
Zunächst nehmen wir vereinfachend an
√
T (n) = 2T (n/ 2) + O(n2 ) .
Dann erhalten wir die folgende grobe Laufzeitabschätzung:
• Die Tiefe der Rekursion ist D = O(log n), weil die Problemgröße jeweils um einen konstanten Faktor abnimmt.
• Auf Rekursionslevel ` (0 ≤ ` ≤ D) sind 2` Teilprobleme
√ `
der Größe n` ≈ n/( 2) zu lösen.
• Die Laufzeitkosten, die wir einem derartigem Problem
zurechnen müssen sind O(n2` ) = O(n2 /2` ).
• Damit sind die Laufzeitkosten, die wir einem Level
zurechnen müssen gleich 2` O(n2 /2` ) = O(n2 ).
Aufsummiert über alle Rekursionslevel ergäbe diese grobe
Rechnung eine Laufzeit von (D + 1) · O(n2 ) = O(n2 log n).
Für einen formalen Beweis müssen wir jedoch berücksichtigen, dass sich die Teilprobleme nicht genau um den Faktor
√
2 verkleinern, sondern etwas größer sind.
24
Details der Laufzeitanalyse
Wir beschreiben ein Kochrezept“ zum Erstellen eines detai”
lierten, formalen Beweises.
1. Sei n` die Größe der Teilprobleme auf Rekursionslevel
` ≥ 0, also die Anzahl der Knoten in den auf diesem
Level vorliegenden Graphen. Zeige per Induktion
n` ≤ n2−`/2 + 2
`−1
X
2−i/2 .
i=0
2. Zeige, es folgt n` ≤ n2−`/2 + 6.83.
3. Das Rekursionsende ist erreicht, wenn n` < 7. Löse
deshalb die Ungleichung
n2−`/2 + 6.83 ≥ 7
nach ` auf. Zeige, es gilt ` ≤ 2 log2 n + 5.12. Also ist die
Rekursionstiefe D = 2 log2 n + O(1).
4. Die dem Rekursionslevel ` zugerechneten Laufzeitkosten
sind durch 2` · O(n2` ) beschränkt. Zeige, dass dieser Term
durch O(n2 ) beschränkt ist.
Fazit: Die Rekursionstiefe ist O(log n). Die Laufzeitkosten
je Rekursionslevel sind O(n2 ). Damit ist die Gesamtlaufzeit
durch O(n2 log n) beschränkt.
u
t
25
Satz 7 Algorithmus Fastcut berechnet einen Min-Cut mit
Wkeit Ω(1/ log n).
Natürlich können wir die Erfolgswkeit durch Amplifikation
auf Kosten der Laufzeit beliebig weiterverbessern.
Um eine konstante Erfolgswkeit zu erreichen benötigen wir
O(log n) Wiederholungen. Das ergibt eine Laufzeit von
O(n2 log2 n).
26
Beweis von Satz 7:
Fixiere einen Min-Cut K. Aus Lemma 5 erhalten wir die
folgende untere Schranke für die Wkeit, dass der Schnitt K
eine Kontraktionssequenz der Länge n − t überlebt.
Y 2
1−
n−i+1
1≤i≤n−t
=
=
=
=
≥
n−i−1
n−i+1
1≤i≤n−t
n−2
n−3
t
t−1
···
n
n−1
t+2
t+1
t(t − 1)
n(n − 1)
√
√
d1 + n/ 2e dn/ 2e
n
n−1
1
.
2
Y
Mit Wkeit mindestens 21 hat der Graph HA also den gleichen
Min-Cut-Wert wie G. Das gleiche Ergebnis gilt für den
Graphen HB .
27
Wir bezeichnen Algorithmus f astcut(G) als erfolgreich,
wenn er einen Min-Cut berechnet. Sei k der Min-Cut-Wert
von G. Die folgenden Bedingungen sind hinreichend für den
Erfolg von f astcut(G).
A) HA hat Min-Cut-Wert k und f astcut(HA ) ist erfolgreich, oder
B) HB hat Min-Cut-Wert k und f astcut(HB ) ist erfolgreich.
Für einen Graphen H, sei P (H) die Wkeit, dass f astcut(H)
erfolgreich ist. Dann ist die Wkeit, dass Bedingung A eintritt,
mindestens 21 P (HA ), weil HA mit Wkeit mindestens 12 den
Min-Cut-Wert k hat. Die Wkeit, dass Bedingung A nicht
eintritt, ist damit höchstens 1 − 12 P (HA ). Bedingung B
verhält sich analog.
Nur wenn beide Bedingungen nicht eintreten, ist f astcut(G)
möglicherweise nicht erfolgreich. Wir erhalten die folgende
untere Schranke:
P (HB )
P (HA )
1−
.
P (G) ≥ 1 − 1 −
2
2
28
Die Tiefe des Rekursionsbaumes von f astcut(G) ist D =
O(log n). Die Rekursionsbäume von f astcut(HA ) bzw.
f astcut(HB ) haben Tiefe D − 1. Dadurch erhalten wir eine
Rekursionsgleichung p(·) für die Erfolgswahrscheinlichkeit
von f astcut, die von der Tiefe des jeweiligen Rekursionsbaumes abhängt.
2
p(d − 1)
p(d) ≥ 1 − 1 −
,
2
falls d ≥ 1 und p(0) = 1.
Behauptung: Für d ≥ 0 gilt p(d) ≥
1
d+1 .
Aus dieser Behauptung folgt
P (G) = p(D) ≥
1
= Ω
D+1
1
log N
.
Damit folgt Satz 7 unmittelbar aus dieser Behauptung.
29
Die Behauptung gilt offensichtlich für d = 0, weil in diesem
Fall die vollständige Suche immer (d.h. mit Wkeit 1) den
Min-Cut berechnet.
Für d ≥ 1 verwenden wir eine Induktion.
2
p(d − 1)
p(d) ≥ 1 − 1 −
2
2
1
≥ 1− 1−
2d
1
1
=
− 2
d 4d
4d − 1
=
2
4d
(4d − 1)(d + 1)
1
=
4d2
d+1
2
4d + 4d − d − 1
1
=
4d2
d+1
1
.
≥
d+1
u
t
Damit ist Satz 7 bewiesen.
30
Monte Carlo vs. Las Vegas
Wir unterscheiden zwei Arten von randomisierten Algorithmen.
• Las-Vegas-Algorithmen berechnen immer die korrekte
Antwort bzw. eine optimale Lösung, nur die Laufzeit
hängt vom Ausgang der Zufallsexperimente ab. Algorithmus SeideLP ist ein Beispiel für einen Las Vegas
Algorithmus, weil er immer eine optimale Lösung berechnet. Die Laufzeit des Algorithmus ist jedoch eine
Zufallsvariable.
• Monte-Carlo-Algorithmen sind durch eine positive, aber
beschränkte Fehlerwahrscheinlichkeit gekennzeichnet.
Typischerweise hängt die Laufzeit nicht von den Zufallsexperimenten ab, sondern ist deterministisch. Die
präsentierten Min-Cut-Algorithmen sind gute Beispiele
für randomisierte Algorithmen vom Typ Monte-Carlo.
Wir untersuchen, unter welchen Bedingungen Las-Vegasin Monte-Carlo-Algorithmen überführt werden können und
umgekehrt.
31
Exkursion: Markov-Ungleichung
Lemma 8 Sei X eine Zufallsvariable mit nicht-negativem
Wertebereich. Für alle t ∈ R+ gilt
Pr [X ≥ t] ≤
E [X]
t
oder, in etwas anderer Schreibweise,
Pr [X ≥ t E [X]] ≤
1
.
t
Beweis: Der Einfachheit halber nehmen wir an der Wertebereich von X ist N0 . Dann gilt
X
E [X] =
i Pr [X = i]
i≥0
≥
X
t Pr [X = i]
i≥t
= t Pr [X ≥ t] .
u
t
32
Satz 9 Gegeben sei ein Las-Vegas-Algorithmus A mit einer
erwarteten Laufzeit von maximal f (n) Rechenschritten für
Eingaben der Länge n. Sei α > 1. Falls wir die Rechnung
von A bei Eingaben der Länge n nach αf (n) Schritten
abbrechen, so erhalten wir einen Monte-Carlo-Algorithmus B
mit Fehlerwahrscheinlichkeit höchstens α1 .
Beweis:
Sei x eine Eingabe der Länge n. Sei T die Zufallsvariable,
welche die Laufzeit von A auf x beschreibt. Es gilt E [T ] ≤
f (n). Algorithmus B macht nur dann einen Fehler, wenn
wir Algorithmus A vorzeitig abbrechen. Aus der MarkovUngleichung folgt somit, dass die Fehlerwahrscheinlichkeit
von B nach oben beschränkt ist durch
1
Pr [T ≥ αf (n)] ≤ Pr [T ≥ αE [T ]] ≤
.
α
u
t
33
Satz 10 Gegeben sei ein Monte-Carlo-Algorithmus B mit
Laufzeit maximal f (n) für Eingaben der Länge n. Sei p(n)
eine untere Schranke für die Wkeit, dass B eine korrekte
Antwort ausgibt. Wir nehmen an, wir haben eine Testroutine,
die die Korrektheit der Ausgabe in Zeit höchstens g(n)
verifiziert. Dann können wir einen Las-Vegas-Algorithmus
A mit erwarteter Laufzeit höchstens (f (n) + g(n))/p(n)
konstruieren.
Beweis:
Algorithmus A ruft Algorithmus B solange auf, bis die
Testroutine die Ausgabe von B als korrekt klassifiziert. Die
Laufzeit pro Iteration ist höchstens f (n) + g(n). Die Wkeit,
dass wir den Algorithmus k mal wiederholen müssen ist nicht
größer als (1 − p(n))k−1 p(n). Die erwartete Anzahl von
Wiederholungen ist somit höchstens
∞
X
k=1
da
∞
X
k=1
kxk =
k(1 − p(n))
k−1
x
.
2
(1 − x)
1
p(n) =
,
p(n)
u
t
34
Las-Vegas-Algorithmen sind somit Monte-Carlo-Algorithmen
überlegen, denn
• ein effizienter Las-Vegas-Algorithmus kann ohne Weiteres in einen effizienten Monte-Carlo-Algorithmus
überführt werden,
• während zur Transformation eines effizienten MonteCarlo-Algorithmus in einen effizienten Las-VegasAlgorithmus ein effizienter, deterministischer Verifizierer
benötigt wird.
35