Seminarvortrag Minimale Schnitte in Graphen

Seminarvortrag
Datenstrukturen und Algorithmen
Professor Hagerup, Professur für Komplexität und Algorithmen
11. Mai 2000
Minimale Schnitte in Graphen
Autoren:
Ernst-Joachim Preussler
Patrick Klein
1
Was ist ein Schnitt?
• Aufteilung der Knotenmenge des Graphen in zwei nicht
leere Partitionen.
• Notation:
1. Menge der Knoten einer Partition.
2. Durchtrennte Kanten
• Beispiel:
a
b
c
d
e
f
Mögliche Notationen für obiges Beispiel:
1. Partition {a, d}
2. Partition {b, c, e, f}
3. Schnittkanten (a,b) und (d,e)
• Beliebige Schnitte zu finden ist trivial.
• Minimale Schnitte zu finden ist nicht trivial.
2
Minimaler Schnitt?
• Ungewichtete Graphen:
ƒ Der Schnitt mit den wenigsten Kanten zwischen zwei
Partitionen.
• Gewichtete Graphen:
ƒ Der Schnitt mit dem geringsten Kantengewicht zwi-
schen zwei Partitionen
ƒ Gewichte sind nichtnegative reelle Zahlen, sonst Pro-
blem NP-vollständig.
• Transformation auf das NP-vollständige Problem des
maximalen Schnittes.
• Analogie beider Varianten
ƒ Setze im ungewichteten Fall das Gewicht jeder Kante
auf Eins.
• Es werden nur zusammenhängende Graphen betrachtet.
ƒ Minimaler Schnitt sonst trivialerweise Null.
3
Bisherige Verfahren
• Berechnung eines maximalen Flusses (Maxflow) in einem
s-t-Netzwerk.
ƒ s-t-Netzwerk ist kantengewichteter Graph.
ƒ Knoten s Quelle, Knoten t Senke eines Netzwerkflusses.
• Wert eines maximalen Flusses entspricht dem Wert eines
minimalen s-t-Schnittes.
ƒ Max-Flow-Min-Cut-Theorem von Ford und Fulkerson.
• Beispiel (minimaler s-t-Schnitt nicht minimaler Schnitt):
2
s
5
3
4
d
1
b
2
t
3
c
2
f
• Maxflow-Algorithmus auf jede s-t-Kombination: Laufzeit quadratisch zur Anzahl der Knoten.
• Knoten s fest, für jedes t Durchlauf: Laufzeit linear zur
Anzahl der Knoten.
4
Laufzeiten
• Mit Maxflow-Algorithmen werden minimale Schnitte in
O(mn log(n²/m)) Zeit berechnet (Hao und Orlin).
• Betrachtung des Min-Cut-Problems ohne Maxflow-Algorithmen verspricht effektivere Ansätze.
ƒ Aber: Schnellere Lösung des Min-Cut-Problems liefert
keine Verbesserung der Maxflow-Algorithmen.
• Algorithmus MINIMUMCUT (Deterministisch)
ƒ Laufzeit von O(nm + n2 log n)
ƒ Findet sicher einen minimalen Schnitt.
• Algorithmus RECURSIVE-CONTRACT (Randomisiert)
ƒ Laufzeit von O(n2 log3 n)
ƒ Findet alle minimalen Schnitte mit hoher Wahrschein-
lichkeit.
5
Anwendungsgebiete
• Ermittlung minimaler Schnitte in Netzwerken.
ƒ Schwachstellen für zufällige Netzzusammenbrüche.
ƒ Randomisierter Algorithmus besser.
• Relationen zwischen Hypertextdokumentgruppen finden.
ƒ Links zwischen den Texten sind Kanten.
ƒ Kleine Schnitte ⇒ Geringe Themenverwandtschaft
ƒ Randomisierter Algorithmus besser.
• Compilierung paralleler Sprachen
ƒ Kanten symbolisieren Prozessorkommunikation.
ƒ Beide Algorithmen geeignet.
• Exakte Lösungen für Traveling-Salesman-Probleme.
ƒ Technik der cutting planes.
ƒ Beide Algorithmen geeignet.
• Verallgemeinerung: Minimierung submodularer Funktionen.
ƒ Submodulare Funktion f auf V hat folgende Eigen-
schaft:
f (Y ) + f ( Z ) ≥ f (Y ∩ Z ) + f (Y ∪ Z )
6
Der Algorithmus MINIMUMCUT
Definitionen:
• Sei G = (V, E) ungerichteter Graph mit der Knotenmenge
V und der Kantenmenge E.
• Jede Kante e ∈ E hat nichtnegatives Gewicht w(e).
• Sei a beliebiger aber fester Startknoten aus V.
• MINIMUMCUTPHASE liefert cut_of_the_phase.
• current_minimum_cut ist aktueller minimaler Schnitt.
Hauptprogramm:
1
PROCEDURE MINIMUMCUT (G, w, a)
2
BEGIN
3
WHILE |V| > 1 DO
4
BEGIN
5
MINIMUMCUTPHASE (G, w, a)
6
IF cut_of_the_phase < current_minimum_cut THEN
current_minimum_cut = cut_of_the_phase
7
END
8
PRINT current_minimum_cut
9
END
7
Prozedur MINIMUMCUTPHASE
Definition:
• Menge A ist Untermenge von V.
ƒ Initialisierung mit Startknoten a.
ƒ Wiederholung der Schleife, solange A ≠ V
Unterprogramm:
PROCEDURE MINIMUMCUTPHASE (G, w, a)
A
BEGIN
B
A ← {a}
C
WHILE A ≠ V DO
D
BEGIN
E
ADD TO A THE MOST TIGHTLY CONNECTED VERTEX
F
END
G
STORE THE Cut_of_the_phase
H
SHRINK G BY MERGING THE TWO VERTICES ADDED LAST
I
END
8
Erläuterungen
Zeile E: ADD TO A THE MOST TIGHTLY CONNECTED VERTEX
• Der Knoten v aus V \ A, der am engsten mit A verbunden
ist, wird zu A hinzugefügt. Bedeutung: Summe der Gewichte der direkten Kanten von A nach v sind maximal.
Zeile G: STORE THE Cut_of_the_phase
• cut_of_the_phase ist der letzte zu A hinzugefügte (Super)Knoten, welcher mit t markiert wird.
Z eile H : S H R IN K G B Y M E R G IN G T H E T W O V E R T IC E S A D D E D L A S T
• Der vorletzte zu A hinzugefügten Knoten (mit s markiert)
und t werden zusammengefaßt (Kontraktion).
ƒ Die Kante (s,t), falls vorhanden, wird entfernt.
ƒ Entstehende Doppelkanten werden mit der Summe der
Kantengewichte als neue Kante zusammengefaßt.
• Beispiel für eine Kontraktion an der Kante (2,3):
1
2
4
5
3
4
2
1
2
5
3
3
2
1
⇒
6
7
3
4
4
9
2 2,3
2
5
3
6
Korrektheitsbeweis
Theorem 1:
Seien s und t zwei Knoten aus G. Sei G / {s,t} der Graph,
der entsteht, wenn s und t zusammengefaßt werden.
Dann ist ein minimaler Schnitt von G das Minimum eines
minimalen s-t-Schnittes von G und eines minimalen
Schnittes von G / {s,t}.
Beweis:
1. Wenn es einen minimalen Schnitt in G gibt, der s und t
trennt (s und t liegen also in verschiedenen Partitionen),
dann ist dies notwendigerweise auch ein minimaler s-tSchnitt in G.
2. Wenn dies nicht der Fall ist, muß sich der minimale
Schnitt in G / {s,t} befinden, da s und t in der selben Partition (bezüglich G) liegen und die Kante (s,t), welche als
einzige Kante in G / {s,t} verschwindet, somit nicht
Schnittkante sein kann.
10
Theorem 2:
Seien s und t die beiden letzten zu A hinzugefügten Knoten.
Dann ist der cut_of_the_phase ein minimaler s-t-Schnitt.
Beweis:
Zu zeigen: Jeder beliebige s-t-Schnitt C ist mindestens so
groß wie der cut_of_the_phase.
Definitionen:
• Knoten v ≠ a ist aktiv (zu C), wenn v und der unmittelbar
vor v zu A hinzugefügte Knoten in unterschiedlichen
Partitionen von C liegen („Partitionswechsel“).
• Sei w(C) Gewicht des beliebigen, aber festen Schnittes C.
• Sei Av die Menge aller Knoten in A vor Hinzunahme von v.
• Sei Cv der Schnitt, der sich (durch C) auf Av ∪ {v} ergibt.
ƒ Sei w(Cv) das Gewicht dieses Schnittes.
Ziel:
• Z.Z.: Für jeden aktiven Knoten v gilt: w(Av, v) ≤ w(Cv).
• ⇒ Da t aktiv, folgt w(At, t) ≤ w(Ct).
• Beachte: w(At, t) = cut_of_the_phase
• Beachte: w(Ct) = w(C)
11
Beweis per Induktion
Annahme:
Für jeden aktiven Knoten v gilt: w(Av, v) ≤ w(Cv).
Verankerung:
Für den ersten aktiven Knoten x gilt: w(Ax, x) = w(Cx).
Induktionsschritt:
Induktionsannahme sei bis zum aktiven Knoten v bewiesen.
Sei u der nächste aktive Knoten, der hinzugefügt wird.
⇒(1)
w(Au, u) = w(Av, u) + w(Au \ Av, u)
E s gilt w (A v , u ) ≤ w (A v , v), d a v am en gsten m it A v v erb u n d en ist.
⇒(2)
w(Au, u) ≤ w(Av, v) + w(Au \ Av, u)
Nach Induktionsannahme gilt w(Av, v) ≤ w(Cv).
⇒(3)
w(Au, u) ≤ w(Cv) + w(Au \ Av, u)
Es gilt: w(Cv) + w(Au \ Av, u) = w(Cu).
⇒(4)
w(Au, u) ≤ w(Cu)
Damit ist die Induktionsannahme bewiesen.
12
Laufzeitanalyse
• MINIMUMCUT hat n-1 Aufrufe von MINIMUMCUTPHASE.
• MINIMUMCUTPHASE: Auswahl des nächsten Knotens.
ƒ Prioritätswarteschlange: Knoten aus V \ A.
ƒ Sortiert nach Kantengewichten von v nach A, also
w(A,v) für alle v aus V \ A.
ƒ Ein Knoten v wird in A eingefügt:
• Der Knoten v muß entfernt werden (EXTRACTMAX).
• Kantengewicht w(A,w) jedes Knotens w aus V \ A
wird um Kantengewicht der Kante (v,w), falls existent,
erhöht (INCREASEKEY).
• INCREASEKEY wird für jede Kante exakt einmal in konstanter Zeit durchgeführt, wird also m-mal benutzt.
• EXTRACTMAX hat (mit Fibonacci-Heaps) eine amortisierte Laufzeit von O(log n) und wird n-mal benutzt.
• ⇒ Laufzeit MINIMUMCUTPHASE: O(m + n log n)
• ⇒ Laufzeit MINIMUMCUT:
O(nm + n² log n) für n Knoten und m Kanten.
13
Randomisierte Algorithmen
• Motivation: Erhoffte schnellere Laufzeit
• Typ: Monte Carlo Algorithmus, d.h. keine Erfolgsgarantie
Algorithmus 1:
Procedure Contract (G)
Solange G noch mehr als zwei Knoten enthält:
Wähle zufällig eine Kante (u,v) aus E;
Verschmelze die Knoten u und v zu einem neuen Knoten u;
Alle Kanten der Form (w,u) oder (w,v) werden zu Kanten
(w,u), für alle w aus V;
Alle Kanten der Form (u,v) werden gelöscht;
Return G.
Zwei Fragen:
• Ist der Schnitt minimal?
• Wie groß ist die Wahrscheinlichkeit, einen minimalen
Schnitt zu finden?
14
Lemma 1.1:
Ein Schnitt (A, B) wird vom Contract-Algorithmus nicht
zerstört ⇔ Keine Kante des Schnittes wird kontrahiert.
Beweis:
⇒: Trivial
⇐: Behauptung: Zwischen zwei Knoten können keine
Kanten unterschiedlichen Typs (Schnittkanten,
Schnittkanten) verlaufen.
Beweis dieser Behauptung durch Induktion
Beispiel:
v
u
w
u‘
w
15
keine
Theorem 1.2:
Ein minimaler Schnitt in G wird durch Contract mit einer
Wahrscheinlichkeit von Ω(n-2) nicht zerstört.
Beweis:
• Naiver Ansatz: Graph, in dem die Knoten in einem Kreis
angeordnet sind, mit n Knoten und n Kanten.
ƒ Wahrscheinlichkeit einen minimalen Schnitt zu finden
ist Eins und es existieren
 n
 
 2
minimale Schnitte.
• Rechnerischer Beweis über Anzahl von Kanten.
2 
 2 

1 − 1 −
 n  n − 1 
n− 2 n −3 n− 4
=
n n −1 n − 2
 2
1 − 
 3
−1
 n
21
2
=
=   = Ω n −2
4 3 n(n − 1)  2 
( )
Korollar 1.3:
Ein minimaler Schnitt (A, B) übersteht die Kontraktion auf
k Knoten mit einer Wahrscheinlichkeit von
k 
 
 2
 n  (k − 1)k
2
  =
= Ω (k n ) , k ≥ 2
 2  (n − 1)n
(
16
)
Algorithmus 2:
Procedure Contract‘ (G)
Solange G aus mehr als zwei Knoten besteht
Wähle eine Kante (u,v) mit einer Wahrscheinlichkeit
gemäß ihres Gewichtes (*)
Verschmelze u und v
Return G
(*)
ƒ Die Gewichte aller Kanten werden aufsummiert.
ƒ Wahrscheinlichkeit, daß eine Kante gewählt wird, ist
Kantengewicht/Gesamtgewicht.
ƒ Hohes Kantengewicht ⇒ hohe Wahrscheinlichkeit, aus-
gewählt zu werden.
• Contract(G,k) ist eine Modifikation des ContractAlgorithmus, dessen äußere Schleife beim Erreichen von
k Knoten terminiert.
Korollar 1.4:
Der Algorithmus Contract findet einen minimalen Schnitt
in G mit einer Wahrscheinlichkeit von Ω(n-2).
17
Implementierung: Auswahl
• Repräsentation durch die Adjazenz-Matrix W und Array
D(u) mit
D (u ) = ∑Wu ,v
v
• Gewichte der ersten k Kanten ergeben den Gewichtsvektor
k
Wk = ∑ wi
i =1
• Wm ist der Vektor über alle m Kantengewichte.
Auswahlverfahren:
• Black-Box Random-Select wählt bei Eingabe des
Gewichtsvektors aus m Kanten in O(log m) Zeit eine
Kante aus.
• Auswahl der Kante (u,v) in O(n) möglich
ƒ u wird mit Wahrscheinlichkeit gemäß D(u) gewählt
ƒ v wird mit Wahrscheinlichkeit gemäß Wu,v gewählt
18
Implementierung: Auswahl
Lemma 2.1:
Wird eine Kante wie beschrieben gewählt, dann ist die
Wahrscheinlichkeit, daß diese Kante gewählt wurde, proportional zu ihrem Gewicht Wu,v.
Beweis:
Sei
σ = ∑ v D (v )
Damit ist σ = 2Wm. Dann ist die Wahrscheinlichkeit
P[(u,v) wurde gewählt] =
D(u ) Wu , v D(v) Wu , v 2Wu , v
=
+
=
= αWu , v
σ D(u )
σ D(v )
σ
Mit α = 1/Wm ist die Wahrscheinlichkeit, eine Kante auf
diese Art zu wählen, gleich der Wahrscheinlichkeit, eine
Kante direkt auszuwählen.
19
Implementierung: Kontraktion einer Kante
Algorithmus 3:
Procedure Edge-Contract (u,v);
D(u) := D(u) + D(v) – 2Wu,v;
D(v) := 0;
Wu,v := Wv,u := 0;
For alle Knoten w außer u und v do
Wu,w := Wu,w + Wv,w;
Ww,u := Ww,u + Ww,v;
Wv,w := Ww,v := 0
Beispiel:
1
2
3
4
1
0
1
1
1
2
1
0
0
1
3
1
0
0
1
4
1
1
1
0
1
2
3
4
1
0
2
2
0
2
2
0
0
0
3
2
0
0
0
4
0
0
0
0
1
2
3
4
1
0
2
0
0
2
2
0
0
0
3
0
0
0
0
4
0
0
0
0
u 1234
D(u) 3 2 2 3
Knoten
1234
Verschmolzen 1 2 3 4
u 1234
D(u) 4 2 2 0
Knoten
1234
Verschmolzen 1 2 3 1
u 1234
D(u) 2 2 0 0
Knoten
1234
Verschmolzen 1 2 1 1
20
Laufzeit: Contract
Korollar 2.2:
Der Contract-Algorithmus kann in O(n²) Zeit ausgeführt
werden.
• Erfolgswahrscheinlichkeit eines Contract-Durchlaufes
(entspricht Contract(G,2)) beträgt Ω(n-2).
• Bessere Erfolgsaussichten mit mehreren Durchläufen.
• Bei dn²ln n Durchläufen beträgt die Wahrscheinlichkeit:
1

1 − 2 
 n 
dn 2 ln n
≤e
− d ln n
≤n
−d
• Aber: Laufzeit O(n4ln n).
• Besser: Berechnungszeit verkürzen durch Verkleinerung
der Teilprobleme.
21
Rekursiver Algorithmus
Algorithmus 4:
Recursive-Contract(G, n)
Eingabe: Ein Graph G mit n Knoten
Falls G weniger als 7 Knoten hat
Dann
G‘:= Contract(G, 2)
Ausgabe: Das Gewicht der Kanten zwischen den beiden resultierenden Knoten
Sonst Wiederhole zweimal
G‘ := Contract(G, n/(√2) + 1)
Recursive-Contract(G‘, n/(√2) + 1)
Ausgabe: Das Minimum der beiden Resultate
22
Lemma 3.1:
D er A lg o rith m u s R ecu rsive-C o n tra ct lä u ft in O (n ² lo g n ) Z eit.
Beweis:
• Zwei unabhängige Kontraktionen des Graphen auf
n/√2+1 Knoten.
• Jeweils rekursiver Aufruf des Algorithmus.
• Die Kontraktionen benötigen jeweils O(n²) Zeit
• Das ergibt folgende Rekursionsgleichung:
 2
 n


+ 1  
T ( n) = 2 n + T  
  2 

• Abschätzung der Lösung mit T(n) = O(n² log n)
Lemma 3.3:
Recursive-Contract findet einen bestimmten minimalen
Schnitt mit einer Wahrscheinlichkeit von Ω(1/log n).
Beweis:
Zwei Bedingungen, um einen minimalen Schnitt zu finden:
• Der Schnitt übersteht eine der beiden Kontraktionen.
• Der Schnitt wird in dem darauf folgenden rekursiven
Aufruf gefunden.
23
Beweis: Lemma 3.3
• Die Erfolgswahrscheinlichkeit, einen minimalen Schnitt
zu finden, ist gleich dem Produkt der Wahrscheinlichkeiten, eine der Kontraktionen zu überstehen, und von einem rekursiven Aufruf gefunden zu werden.
• Wahrscheinlichkeit, die Kontraktion zu überstehen, ist:
(
)(
 )
 n / 2 +1 n / 2 +1 −1  1

≥

 2
−
(
1
)
n
n


• Erfolgswahrscheinlichkeit von Contract ist bei 6 Knoten
mindestens 1/15.
• ⇒ Rekursionsgleichung für P(n):
2
  1  n

 

1 − 1 − P 
+1 
  2   2   
P (n ) ≥  

1


15
falls n ≥ 7
sonst
• Es genügt, eine untere Schranke für P(n) zu berechnen.
• Lösung durch Variablenersetzung.
• pk = Erfolgswahrscheinlichkeit auf der k-ten Ebene der
Rekursion.
24
Beweis: Lemma 3.3
• Ein Blatt liegt auf Ebene 0.
1
15
2
1


= 1 − 1 − p k 
 2 
=
p0
pk +1
z0
z k +1
=
= pk −
1 2
pk
4
59
1
= zk + 1 +
zk
• zk = 4/pk – 1, also pk = 4/(zk + 1).
• zk ≥ 1 ⇒ (Induktion) k < zk < 59 + 2k ⇒ zk = Θ(k)
⇒ pk = Θ(1/k)
• Daraus folgt (Logarithmusreihe):
P(n) ≥ p2 log 2 n + O (1)
 1 

= Θ
 log n 
• Wahrscheinlichkeit, einen bestimmten minimalen Schnitt
zu finden, liegt in Ω(1/log n).
25
Erfolgswahrscheinlichkeit Recursive-Contract
Theorem 3.4:
Alle minimalen Schnitte in einem gewichteten Graphen mit
n Knoten und m Kanten können mit hoher Wahrscheinlichkeit in O(n²log³n) Zeit und O(m log (n²/m)) Platz gefunden
werden.
Beweis:
Es existieren maximal (n²-n)/2 minimale Schnitte in einem
Graphen. Wird Recursive-Contract O(log²n)-mal wiederholt, dann ist die Wahrscheinlichkeit durch O(1/n4) beschränkt, einen bestimmten minimalen Schnitt nicht zu finden. Also ist die Wahrscheinlichkeit, einen der maximal
(n²-n)/2 minimalen Schnitte zu verpassen, durch
 n2 − n 
 1 
 = O 2 
O
4 
n 
 2n 
nach oben beschränkt.
26
Gesicherte logarithmische Laufzeit von
Random-Select
• Betrachtung ist nötig, falls das Gesamtgewicht aller
Kanten nicht mehr polynomiell in m ist.
Hier nur der Ansatz:
• Setze N=tm4 und wähle eine Zufallszahl s aus [0,N]
• Wähle Kante i mit Wi-1 ≤ Wm s/N < Wi.
• Fehler tritt auf, wenn Wn s/N und Wn (s+1)/N verschiedene Kanten referieren.
• Die Wahrscheinlichkeit dafür liegt bei m/N = O(1/tm3).
27
Ergebnisse:
• Berechnung minimaler Schnitte mittels Probabilismus ist
in O(n²log³n) mit einer Fehlerwahrscheinlichkeit von
O(1/n²) möglich.
• Verbesserung durch Parallelisierung auf geeigneten Maschinenmodellen.
• Berechnung von Mehrfachschnitten (Graph wird in r > 2
Partitionen aufgeteilt) in O(n2(r-1)log²n) Zeit möglich.
• Berechnung von fast-minimalen Schnitte in einer
α-Umgebung um den minimalen Schnitt (Wert liegt im
Intervall [c, αc], α > 1) in O(n2αlog²n) Zeit möglich.
28