Randomisierte Algorithmen - Kapitel 1

Randomisierte Algorithmen
Kapitel 1
Markus Lohrey
Universität Leipzig
http://www.informatik.uni-leipzig.de/~lohrey/RAND
WS 2005/2006
Markus Lohrey (Universität Leipzig)
Randomisierte Algorithmen
WS 2005/2006
1 / 31
Organisatorisches
Vorlesung:
Di, 14.15 15.45, Raum 1.29
Di, 16.15 17.00, Raum 1.29
Übung:
Di, 17.00 17.45, Raum 1.29
Literatur:
R. Motwani, P. Raghavan. Randomized Algorithms. Cambridge
University Press
Markus Lohrey (Universität Leipzig)
Randomisierte Algorithmen
WS 2005/2006
2 / 31
Beispiel 1: Quicksort
Randomisierter Algorithmus:
Klassischer deterministischer Algorithmus erweitert um Zufallskomponente
(Münzwurf ).
Quicksort:
Gegeben: Menge S von n Zahlen
Gesucht: S in sortierter (aufsteigender Reihenfolge)
Klassischer QS
1
Wähle ein Element y
2
S1
3
Sortiere rekursiv S1 .
:= {x ∈ S | x < y },
Sortiere rekursiv S2 .
4
∈ S.
S2
=⇒
=⇒
:= {x ∈ S | y < x }
Liste L1
Liste L2
Output: L1 yL2
Markus Lohrey (Universität Leipzig)
Randomisierte Algorithmen
WS 2005/2006
3 / 31
Quicksort
Problem
Wie wählt man y in Schritt (1)? Optimale Wahl von y falls |S1 |, |S2 |
< n/2
(Median von S ).
Der Median von S kann in Zeit O (n ), d.h. Zeit c
·n
für Konstante c ,
gefunden werden (relativ kompliziert).
=⇒
T (n )
≤ 2 · T (n/2) + (c + 1) · n
=⇒
T (n )
∈O
Angenommen wir würden in Schritt (1) in Zeit O (n ) ein y
|S1 |, |S2 | ≤
=⇒
3/4 · n nden (davon gibt es
T (n )
≤ 2 · T (3/4 · n) + O (n)
Markus Lohrey (Universität Leipzig)
n/2
n · log(n)
∈S
mit
viele).
=⇒
Randomisierte Algorithmen
T (n)
∈O
n · log(n)
WS 2005/2006
4 / 31
y
Randomisierte Wahl von
Algorithmus randQS
∈S
1
Wähle ein y
2
zufällig und gleichverteilt aus S .
S1
3
Sortiere rekursiv S1
:= {x ∈ S | x < y },
Sortiere rekursiv S2
4
S2
=⇒
=⇒
:= {x ∈ S | y < x }
Liste L1
Liste L2
Output: L1 yL2
Analyse von randQS
Für 1
≤i ≤n
S(i )
sei
= das
Element von Rank i in S = das
eindeutige s
∈S
mit
|{y ∈ S | y ≤ s }| = i .
Deniere Zufallsvariable Xij durch:
(
Xij
=
1
falls S(i ) und S(j ) in einem Ablauf von randQS verglichen werden
0
sonst
Markus Lohrey (Universität Leipzig)
Randomisierte Algorithmen
WS 2005/2006
5 / 31
Analyse von randQS
Wir wollen den Erwartungswert E [V ] für die Anzahl V der Vergleiche in
einem Ablauf von randQS berechnen.


n X
n X
X
X
Xij  =
E [Xij ]
E [V ] = E 
i =1 j >i
i =1 j >i
Linearity of Expectations
Sei pij
= Prob[S(i )
und S(j ) werden verglichen].
=⇒
Markus Lohrey (Universität Leipzig)
E [Xij ]
= 1 · pij + 0 · (1 − pij ) = pij
Randomisierte Algorithmen
WS 2005/2006
6 / 31
Analyse von randQS
Ein Ablauf von randQS kann durch einen binären Suchbaum T
beschrieben werden.
y
Element, das in Schritt (1) gewählt wird
S1
S2
∀x ∈ S1 : x < y
∀x ∈ S2 : x > y
Beobachtung
a
∈S
wird mit b
⇐⇒
∈S
verglichen
a ist Vorgänger von b in T oder b ist Vorgänger von a in T
Markus Lohrey (Universität Leipzig)
Randomisierte Algorithmen
WS 2005/2006
7 / 31
Analyse von randQS
Beispiel: S
= {1, . . . , 10}
4
2
Level-Order-Traversal
9
π(T )
von T :
1
3
7
6
10
4, 2, 9, 1, 3, 7, 10, 6, 8, 5
8
5
Lemma
S(i ) wird mit S(j ) verglichen (i < j ) genau dann, wenn es
i < l < j , welches in π(T ) vor S(i ) und S(j ) steht, gibt.
Markus Lohrey (Universität Leipzig)
Randomisierte Algorithmen
kein
S(l ) mit
WS 2005/2006
8 / 31
Analyse von randQS
B
Beweis, ⇒:
Angenommen S(l ) (i
steht in
S(j ) .
π(T )
< l < j)
vor S(i ) und
Weder S(i ) kann Vorgänger
von S(j ) sein, noch S(j ) kann
S( l )
Vorgänger von S(i ) sein.
=⇒
S(i ) und S(j ) werden
nicht verglichen.
hier muss
(<
Markus Lohrey (Universität Leipzig)
S( ) )
l
S( )
i
sein
Randomisierte Algorithmen
hier muss
(>
S( ) )
l
S( )
j
sein
WS 2005/2006
9 / 31
Analyse von randQS
Beweis, ⇐:
Angenommen S(i ) wird nicht mit S(j ) verglichen.
=⇒
von S(j ) und S(j ) kein Vorgänger von S(i ) .
S(i ) kein Vorgänger
T
S(i )
S(i )
< S(l ) < S(j )
S(j )
und S(l ) vor S(i ) und S(j ) in
Markus Lohrey (Universität Leipzig)
π(T ).
Randomisierte Algorithmen
WS 2005/2006
10 / 31
Analyse von randQS
Beobachtung:
Jedes Element aus dem Intervall I
= {S(i ) , S(i +1) , . . . , S(j ) } ⊆ S
ist mit
gleicher Wahrscheinlichkeit das erste Element aus I in der Liste
Diese Wahrscheinlichkeit ist somit 1/|I |
E [V ]
Es gilt: Hn
=
n X
X
pij
=
= 1/(j −i +1).
n X
X
π(T ).
2
=⇒ pij = /(j −i +1).
2
j −i +1
i =1 j >i
i =1 j >i
n X
n
n nX
−i +1
X
X
1
1
=2·
≤2·
k
k
i =1 k =1
i =1 k =2
n
X
1
=2·n·
= n'te Harmonische
k
k =1
Zahl Hn
∈ Θ(log(n))
Markus Lohrey (Universität Leipzig)
Randomisierte Algorithmen
WS 2005/2006
11 / 31
Analyse von randQS
Satz
Der Erwartungswert E [V ] für die Auswahl von Vergleichen von randQS ist
in
O(n · log(n)).
Bemerkungen:
randQS ist ein Las Vegas Algorithmus. Er liefert stets das richtige
Ergebnis, aber die Rechenzeit ist Zufallsvariable.
E [V ]
∈ O(n · log(n))
gilt für jeden Input. Keine Annahmen über
Wahrscheinlichkeitsverteilung für Input S .
Zufallsbits (=Münzwürfe) sollten als Rechenressource (wie Zeit und
Speicher) angesehen werden. Wie viele Zufallsbits sind nötig um ein
Element y zufällig und gleichverteilt aus einer Menge S auszuwählen?
Markus Lohrey (Universität Leipzig)
Randomisierte Algorithmen
WS 2005/2006
12 / 31
Beispiel 2: Randomisierter Min-Cut-Algorithmus
Sei G ein zusammenhängender ungewichteter Multigraph (d.h. mehrere
).
Kanten zwischen zwei Knoten, aber keine Schlingen
Beispiel:
V (G )
= Menge
der Knoten von G
E (G )
= Menge
der Kanten von G
5
j
|V (G )| = n
zusammenhängend ist. Beispiel:
1
g
h
e
k
4
Ein Cut von G ist eine Menge C
f
i
2
⊆ E (G ), so dass G \ C
{f , g } ist Cut im obigen
3
nicht mehr
Graph.
Ein Min-Cut von G ist ein Cut C von G , so dass kein Cut C
|C 0 | < |C |
0 von G mit
existiert. Min-Cut-Size(G ) = Gröÿe eines (beliebigen) Min-Cut
von G . Beispiel: Min-Cut-Size(G )
Markus Lohrey (Universität Leipzig)
=2
für obigen Graphen.
Randomisierte Algorithmen
WS 2005/2006
13 / 31
Randomisierter Min-Cut-Algorithmus
Sei e eine Kante von G . merge(G , e ) ist der Multigraph, der durch
Verschmelzen der Endpunkte von e entsteht (entstehende Schleifen werden
entfernt).
Beispiel:
5
1
5
e
4
2
3
Kontrahieren von e
−−−−−−−−−−−→
4
merge(G , e )
G
Markus Lohrey (Universität Leipzig)
3
Randomisierte Algorithmen
WS 2005/2006
14 / 31
Randomisierter Min-Cut-Algorithmus
randMin-Cut
while G hat noch mindestens 3 Knoten do
wähle zufällig und gleichverteilt Kante e
G
∈ E (G )
aus
:= merge(G , e )
od
% G hat nun noch genau zwei Knoten
output E (G )
Bemerkungen:
Zeitbedarf stets n
−2
(n
= |V (G )|)
Liefert randMin-Cut stets einen Min-Cut von G zurück? Nein!
Lemma
Sei e
∈ E (G ).
Min-Cut-Size(G )
Markus Lohrey (Universität Leipzig)
≤ Min-Cut-Size(merge(G,e))
Randomisierte Algorithmen
WS 2005/2006
15 / 31
Randomisierter Min-Cut-Algorithmus
Beweis:
Sei C ein Min-Cut von G
0
= merge(G , e ).
Knoten, der
durch Kontra-
G0
hieren von
e
G
e
entsteht.
C
C
C ist auch ein Cut von G .
=⇒
Min-Cut-Size(G )
Markus Lohrey (Universität Leipzig)
≤ |C | = Min-Cut-Size(G 0 )
Randomisierte Algorithmen
WS 2005/2006
16 / 31
Analyse von randMin-Cut
Sei v
∈ V (G ).
d (v )
Grad von v :
= Anzahl
Beobachtung: |E (G )|
der Kanten, die v als Endpunkt haben
= 1/2 ·
P
v ∈V (G ) d (v )
Betrachte einen festen Min-Cut C von G . k
= |C | = Min-Cut-Size(G ).
Angenommen, in einem Ablauf von randMin-Cut wird nie eine Kante e
kontrahiert.
=⇒
∈C
randMin-Cut liefert C als Output und somit ein korrektes
Ergebnis.
Wir schätzen die Wahrscheinlichkeit
Prob[keine Kante aus C wird kontrahiert]
ab. Sei Ei das Ereignis, dass im i -ten Durchlauf der while-Schleife keine
Kante aus C kontrahiert wird.
Markus Lohrey (Universität Leipzig)
Randomisierte Algorithmen
WS 2005/2006
17 / 31
Analyse von randMin-Cut
hV
i
n−2 E
i
i =1
h
i
V
= Prob[E1 ] · Prob[E2 |E1 ] · Prob[E3 |E1 ∧ E2 ] · . . . · Prob En−2 | nj =−13 Ej
Prob[keine Kante aus C wird kontrahiert]
Sei Gi der Graph nach dem
Es ist |V (Gi )|
=n−i +1
(i − 1)-ten
= Prob
Schleifendurchlauf (d.h. G1
und Min-Cut-Size(Gi )
= G ).
≥ k = Min-Cut-Size(G )
(wegen Lemma).
Behauptung: |E (Gi )|
≥ k ·(n−2i +1)
P
< k ·(n−2i +1) . =⇒ 21 · v ∈V (G ) d (v ) < 21 · k · |V (Gi )|.
=⇒ Es existiert ein Knoten v ∈ V (Gi ) mit d (v ) < k . Da
{e ∈ E (Gi ) | v ist Endpunkt von e } ein Cut von Gi ist, folgt:
Min-Cut-Size(Gi ) < k . Widerspruch!
Beweis: Sei |E (Gi )|
Markus Lohrey (Universität Leipzig)
i
Randomisierte Algorithmen
WS 2005/2006
18 / 31
Analyse von randMin-Cut
Angenommen, es gilt
Vi −1
j =1 Ej ,
d.h. in den Schleifendurchläufen 1, . . . , i
−1
wird keine Kante aus C kontrahiert.
=⇒
h
Prob Ei |
Vi −1 i
|C |
j =1 Ej = 1 − |E (G )
i
k
≥ 1 − k ·(n−i +1) = 1 −
2
2
n
−i +1
=
n
n
−i −1
−i +1
Also ergibt sich:
Prob[keine Kante aus C wird kontrahiert]
h V
i
Qn −2
i −1 E ≥ Qn−2 n − i − 1
Prob
E
|
i j =1 j
i =1
i =1 n − i + 1
n−2 n−3 n−4
3 2 1
=
·
·
· ... · · ·
n
n−1 n−2
5 4 3
=
=
2
n (n
− 1)
Markus Lohrey (Universität Leipzig)
≥
2
n2
Randomisierte Algorithmen
WS 2005/2006
19 / 31
Analyse von randMin-Cut
Satz
Ein Ablauf von randMin-Cut liefert mit Wahrscheinlichkeit mindestens 2/n2
einen Min-Cut zurück (n
Markus Lohrey (Universität Leipzig)
=
Anzahl der Knoten des Eingabebaumes).
Randomisierte Algorithmen
WS 2005/2006
20 / 31
Analyse von randMin-Cut
Wahrscheinlichkeitsverstärkung (probability amplication):
Wir wiederholen nun randMin-Cut
n /2 · (n − 2))
2
n2/2
mal (
=⇒
Gesamtlaufzeit:
und liefern den kleinsten Cut aus den einzelnen
Wiederholungen zurück.
Prob[keine der
n2/2
≤ (1 − 2/n2 )
· n2
< (1/e )20 .
Bei 10
2
n
/2
Wiederholungen liefert einen Min-Cut]
< 1/e
(e
=
Eulersche Konstante)
Wiederholungen ergibt sich eine Fehlerwahrscheinlichkeit von
Bemerkungen:
Wahrscheinlichkeitsverstärkung ist unter Beibehaltung einer
polynomiellen Laufzeit möglich, falls Fehlerwahrscheinlichkeit für einen
Durchlauf
< 1 − 1/p(n)
für ein Polynom p (n ) gilt:
(1 − 1/p(n))p(n) < 1/e
randMin-Cut ist ein Monte-Carlo-Algorithmus: Er liefert nur mit einer
Wahrscheinlichkeit
Markus Lohrey (Universität Leipzig)
<1
ein richtiges Ergebnis.
Randomisierte Algorithmen
WS 2005/2006
21 / 31
Beispiel 3: Binäre planare Partitionen
Denition: Eine binäre planare Partition ist ein binärer Baum P .
Jedem Knoten von P ist eine (evtl. unendliche) Region r (v )
⊆ R2
zugeordnet.
Für die Wurzel u von P gilt r (u )
= R2 .
Jedem internen Knoten v von P (d.h. jedem Nicht-Blatt) ist weiterhin
eine Gerade l (v ) zugeordnet, die r (v ) schneidet.
=⇒ l (v )
teilt r (v ) in zwei Regionen r1 und r2 auf. Diese Regionen
sind den beiden Kindern von v zugeordnet.
l
(v )
r
r
r
Markus Lohrey (Universität Leipzig)
(v )
(v1 )
(v2 )
Randomisierte Algorithmen
v
v1
v2
WS 2005/2006
22 / 31
Binäre planare Partitionen
Sei nun S
= {s1 , . . . , sn } eine Menge von Geradensegmenten (endlicher
∩ sj = ∅ für i 6= j . Eine binäre planare Parition P von S ist
Länge) mit si
eine binäre planare Partition P , so dass für jedes Blatt v von P gilt: Es gibt
höchstens ein 1
≤i ≤n
mit si
∩ r (v ) 6= ∅.
l (v1 )
Beispiel:
r (v7 )
v1
P:
v2
r (v4 )
v3
v4 v5 v6 v7
l (v2 )
s1
s2
r (v5 )
l (v3 )
r (v6 )
s3
Ziel: Finde binäre planare Partition P von S mit möglichst wenig
Baumknoten (bzw. wenig Regionen).
Markus Lohrey (Universität Leipzig)
Randomisierte Algorithmen
WS 2005/2006
23 / 31
Binäre planare Partitionen
Für ein Geradensegment si sei l (si ) die Gerade mit si
Autopartition von S
= {s1 , . . . , sn }
⊆ l (si ).
Eine
ist eine binäre planare Paritition P von
S , so dass für jeden internen Knoten v des Baums P ein i mit l (v )
= l (si )
existiert.
Bemerkung: Für eine Autopartition P von S kann natürlich ein si
∈S
genau auf der Grenze von 2 Regionen r1 und r2 liegen. Wir ordnen dann si
entweder r1 oder r2 zu.
Beispiel:
Markus Lohrey (Universität Leipzig)
Randomisierte Algorithmen
WS 2005/2006
24 / 31
Binäre planare Partitionen
Algorithmus randAuto
Input: Menge S
= {s1 , . . . , sn }
Output: Autopartition P von S
von Geradensegmenten, si
π
1
Wähle zufällig und gleichverteilt eine Permutation
2
while Es gibt Region r , die mit mindestens zwei s
∩ sj = ∅
von
∈S
für i
6= j
{1, . . . , n}
einen
nicht-leeren Schnitt hat do
Sei k
Teile
od
= min{i | r ∩ sπ(i ) 6= ∅}.
r mit l (sπ(k ) ) auf.
Für Geradensegmente si , sj
index(si , sj )
=


∞
k
∈S
sei
falls l (si ) nicht sj . schneidet
falls l (si ) genau k


Markus Lohrey (Universität Leipzig)
−1
Geradensegmente schneidet,
bevor l (si ) auf sj trit.
Randomisierte Algorithmen
WS 2005/2006
25 / 31
Analyse von randAuto
Beispiel:
s4
s3 s2
s5
s1
s6
s7
s8
index(s1 , s4 )
si
= index(s1 , s7 ) = 3,
a sj ⇐⇒ l (si )
index(s1 , s8 )
=∞
schneidet sj in der Autopartition, die randAuto erzeugt.
= k für u , v ∈ S und seien u1 , . . . , uk −1 ∈ S
die Geradensegmente, die l (u ) schneidet, bevor l (u ) auf v trit. Dann gilt:
u a v =⇒ u steht in der Zufallspermutation π vor allen Elementen
u1 , . . . , uk −1 (, v ).
Beobachtung: Sei index(u , v )
u1
u2
u3
v
u
Markus Lohrey (Universität Leipzig)
Randomisierte Algorithmen
WS 2005/2006
26 / 31
Analyse von randAuto
Prob[u steht in
(
Cu ,v
E [Cu ,v ]
=
π
vor u1 , . . . , uk −1 (, v )]
1
falls u
0
sonst
av
= Prob[u a v ] ≤
=
1
k (+1)
(Indikatorvariable)
1
k (+1)
=
1
index(u , v )(+1)
Sei P die Autopartition von S , die randAuto produziert. Anzahl der
Regionen von P = n (Anzahl der Geradensegmente) + Anzahl der
Schnitte von Geradensegmenten.
=⇒
E [Anzahl der Regionen]
=n+
=
n
P
P
u∈S v ∈S E [Cu,v ] ≤
v 6=u
Markus Lohrey (Universität Leipzig)
+E
n
P
+
u ∈S
v ∈S Cu,v
v 6=u
P
P
P
1
u∈S v ∈S index(u , v )(+1)
v 6=u
Randomisierte Algorithmen
WS 2005/2006
27 / 31
Analyse von randAuto
Beobachtung: Für ein k
index(u , v )
∈N
und u
∈S
gibt es höchstens zwei v
∈S
mit
= k.
=⇒
X
1
v ∈S
v 6=u
index(u , v )(+1)
E [Anzahl der Regionen von P ]
Markus Lohrey (Universität Leipzig)
≤
n
+n·
≤
n −1
X
k =1
n−1
X
2
k (+1)
2
≤
n
+ 2n ·
k (+1)
k =1
= n + 2n · Hn ∈ Θ(n · log(n))
Randomisierte Algorithmen
n
X
k =1
WS 2005/2006
1
k
28 / 31
Analyse von randAuto
Satz
Der Erwartungswert für die Gröÿe der von randAuto konstruierten
Autopartition von S
= {s1 , . . . , sn }
ist in
O(n · log(n)).
Folgerung
= {s1 , . . . , sn } von Geradensegmenten mit
i 6= j =⇒ si ∩ sj = ∅ existiert eine binäre planare Partition von
Gröÿe O(n · log(n)).
Für jede Menge S
S der
Begründung: Eine Zufallsvariable X muss mit Wahrscheinlichkeit
Wert
≥ E [X ]
>0
einen
annehmen können.
Probabilistische Methode zum Beweis der Existenz eines bestimmten
kombinatorischen Objekts (hier: einer binären planaren Partition).
Markus Lohrey (Universität Leipzig)
Randomisierte Algorithmen
WS 2005/2006
29 / 31
Randomisierte Komplexitätsklassen
Eine Sprache L
⊆ Σ∗
gehört zur Klasse RP (randomisierte Polynomialzeit),
falls ein randomisierter Algorithmus A existiert mit:
Es gibt ein Polynom p (n ), so dass A auf jeder Eingabe x
∈ Σ∗
höchstens p (|x |) Schritte rechnet.
x
x
∈ L =⇒
∈
/ L =⇒
≥ 1/2
x] = 0
Prob[A akzeptiert x ]
Prob[A akzeptiert
Bemerkung: Die Wahrscheinlichkeitsschranke 1/2 kann durch
Wahrscheinlichkeitsverstärkung erhöht werden.
Eine Sprache L gehört zur Klasse coRP genau dann, wenn L
Eine Sprache L
⊆
∈ RP.
Σ∗ gehört zur Klasse ZPP (Zero-Error Probabilistic
Polynomial Time), falls ein randomisierter (Las Vegas) Algorithmus
existiert mit:
Es gibt ein Polynom p (n ), so dass für jede Eingabe x
E [Rechenzeit von A bei Eingabe x ]
x
x
∈ L =⇒
∈
/ L =⇒
∈ Σ∗
gilt:
≤ p (n).
Prob[A akzeptiert x ]
Prob[A akzeptiert
Markus Lohrey (Universität Leipzig)
=1
x] = 0
Randomisierte Algorithmen
WS 2005/2006
30 / 31
Randomisierte Komplexitätsklassen
Satz
ZPP
= RP ∩ coRP
Beweis: Übungen
Markus Lohrey (Universität Leipzig)
Randomisierte Algorithmen
WS 2005/2006
31 / 31