Vorlesungsfolien Fibonacci-Heaps II, Minimale Schnitte

Amortisierte Analyse
Fibonacci-Heaps II
Minimale Schnitte
z
Einfacher Ausflug: Stacks
Operationen
z
Laufzeit für Folge von n Operationen?
z
z
Sternstunden der Algorithmik
15. Juni 2004
Gunnar W. Klau
z
z
z
z
Gleiches Ergebnis mit Potenzialfunktion Φ
Φ(D) sagt, wie gut oder schlecht die aktuelle
Konfiguration der Datenstruktur D ist
z
z
Dazu Potenzial mathematisch beschreiben:
z
Amortisierte Kosten einer Operation sind
z
z
Analogie: Bankkonto
z
z
z
Künstliche Verteuerung billiger Operationen
(„Einzahlen“)
Teure Operationen dürfen „abheben“, um die
amortisierten Kosten zu senken
z
z
z
z
Fibonacci-Heaps: Analyse
Dann ist die Summe der amortisierten Kosten
n
n
n
i=1
i=1
i=1
Wir wählen eine Potenzialfunktion, die
z
z
z
z
Σ ti ≤ Σ a i
ai
ti
Φi
Φ0
amortisierte Kosten für Operation oi
tatsächliche Kosten für Operation oi
Potenzial direkt nach Operation oi
Potenzial vor o1
Zurück zu den Stacks:
z Φ(S) = |S|
z Reale Kosten push, pop: 1, multipop: k
z
nichtnegativ und
am Anfang gleich Null ist
Dann ist Φn – Φ0 ≥ 0 und damit
tatsächliche Kosten + ∆Φ
also auch Belastung durch zukünftige Kosten (insert)
oder Entschärfung von teuren Operationen (∆Φ negativ).
Amortisierte Analyse
Σai = Σ(ti + Φi – Φi-1) = Φn – Φ0 + Σti
z
Funktion Φ, die jeden Heap auf eine reelle Zahl abbildet
Sei o1,...,on eine Folge von n Operationen
z
z
jedes Element kann nur einmal durch eine
pop/multipop-Operation gelöscht werden:
O(n)
Fibonacci-Heaps: Analyse
Amortisierte Analyse
z
push: O(1), pop: O(1) multipop: O(n)
→ O(n2)
etwas pessimistisch
z
z
push(S,x), pop(S) und multipop(S,k)
z
Betrachte i-te Operation
z
push: ai = 1 + |Si| - |Si -1| = 1 + (|Si -1| + 1) - |Si -1| = 2
z
multipop: ai = k + |Si| - |Si -1| = k + (|Si -1| - k) - |Si -1| = 0
Folge von n Operationen hat also amortisierte
Kosten
1
Fibonacci-Heaps: Analyse
z
z
Zurück zu den Fibonacci-Heaps
Konkrete Wahl von Φ?
z
z
z
Fibonacci-Heaps: Analyse
z
extractMax:
z
Was kann später große Kosten verursachen?
Sicher Anzahl der Wurzeln W!
Provisorisch: Φ = αW
z
z
z
fängt mit W1 Wurzeln an, hört mit W2 auf, entfernter
Knoten hatte Grad d
tatsächliche Kosten ti = c(d + W1), c Konstante
∆Φ = α(W2 – W1), also amortisierte Kosten:
ai = c(d + W1) + α(W2 – W1) = (c – α)W1 + cd + αW2
Wir wählen α = c, also
ai = cd + αW2
z
z
Fibonacci-Heaps: Analyse
z
increaseKey:
z
z
z
z
z
z
z
z
amortisierte Kosten
ai = c´(k + 1) + αk + β(2 – k)
= (c´ + α – β)k + c´+ 2β
Wähle β = c´+ α, es folgt
ai = 3c´ + 2α = O(1)
∆Φ ≤ αk + β(2 – k), denn alle neuen Wurzeln waren
aufgeregt (bis auf vielleicht eine), höchstens ein
Knoten regt sich neu auf. (s. Bsp. auf voriger Folie)
Nein, denn dort werden keine Knoten an- oder
abgeregt und A bleibt unberührt.
insert:
z
z
Werden leicht zu Wurzeln und verursachen dabei noch
Arbeit, also Φ = αW + βA
Müssen wir extractMax neu abschätzen?
z
increaseKey (Forts.):
tatsächliche Kosten ti = c´(k + 1), c´ Konstante
Fibonacci-Heaps: Analyse
z
z
Problem: teuer und erhöht Potenzial...
Zweite Quelle für Φ: aufgeregte Knoten A
z
also ai = O(log n)
Fibonacci-Heaps: Analyse
schafft k neue Wurzeln
z
aber d = O(log n) und W2 = O(log n), denn alle Wurzeln
haben unterschiedlichen Grad
Erhöht die Anzahl der Wurzeln um 1
ai = ti + α = O(1+ α) = O(1)
Resultat
z
Eine Folge von n insert-, min- und
increaseKey- und m · n
deleteMax-Operationen auf einem
anfänglich leeren Fibonacci-Heap
können in Zeit O(n + m log n)
ausgeführt werden.
Klar, dass Φ nichtnegativ und am Anfang 0
2
Warum „Fibonacci“-Heap?
z
Verschärfte Version eines Lemmas, das wir
bewiesen haben:
Minimale Schnitte
Jeder Knoten vom Grad k hat mindestens
Fk+2 Nachkommen.
(k+2)-te Fibonacci-Zahl
Problem
z
z
z
Beispiel
Gegeben: Graph G = (V, E) mit
Kantengewichten ce ∈ R≥ 0 ∀ e ∈ E
NPschwer
für ce ∈ R
3
Gesucht: Schnitt S ⊂ V, ∅ ≠ S ≠ V, kleinsten
Gewichts („min cut“)
Definitionen/Schreibweisen:
Gewicht eines Schnittes:
z
z
z
z
z
z
Fixiere einen Knoten r ∈ V
Beobachtung:
Jeder Schnitt ist auch r-s-Schnitt für einen
Knoten s ≠ r, also auch der minimale Schnitt
wie geht das?
Algorithmus:
Berechne minimalen r-s-Schnitt ∀ s ∈ V \{r}
min cut = kleinster dieser Schnitte
Mit vielen Tricks [Hao, Orlin 1992]:
komplizierter
Algorithmus
2
2
6
3
4
3
2
7
1
4
2
3
8
Anwendungen:
z
Max-Flow-Algorithmus
3
2
2
5
z
z
2
1
Design von Kommunikationsnetzen (reliability)
Tagebau
Baseball elimination
Algorithmus ohne Flüsse
z
z
Nagamochi/Ibaraki, 1992
Frank, 1994
„einfach“
Stör/Wagner, 1997
Def.: Operation Knoten-Identifikation
„ziehe zwei Knoten u und v zusammen“
2
1
G
3
2
5
2
3
3
2
2
2 2,7
6
3
3
1
1
2
4
4
2
2
2
1
7
3
Guv
8
3
Idee
z
z
z
Beobachtung:
Alle Schnitte des Graphen Guv entsprechen
Schnitten in G, die u und v nicht trennen.
Folgerung:
min cut = min{min cut(Guv), min. u-v-cut}
Algorithmus:
Problem
z
Wie berechne ich r-s-Cut in Schritt 1)?
z
z
z
Dazu definiere legale Ordnung:
z
1) Wähle 2 Knoten r und s und bestimme
min. r-s-Schnitt C
Mit Fluss? Nichts gewonnen.
Idee: Wähle r und s so, dass der minimale Schnitt
einfacher berechnet werden kann.
z
v1 beliebig
vi ist Knoten u mit größtem Gewicht
2) Cmin := min(Cmin, C)
3) identifiziere(r, s) → Grs
4) |V| > 1 ? goto 1)
Lösung
z
z
Theorem 1:
Sei v1, v2, ..., vn eine legale Ordnung von G.
Dann ist δ({vn}) ein minimaler vn-1-vn-Schnitt.
Beweis:
Übung.
von Kanten zu {v1, v2, ..., vi-1} für alle i.
Berechnung der legalen
Ordnung
z
z
z
Prioritätswarteschlange Q enthält alle Knoten
nicht in {v1, ..., vi-1}
Schlüssel(v) = ci-1(v)
Beispiel an der Tafel (mitschreiben!)
2
1
3
2
5
3
Korrektheit
MINCUT(G)
z
z
3
2
Algorithmus
Sei v1 beliebiger Knoten in G; S = {v1}; n = |V(G)|;
for i = 2 to n {
vi ist derjenige Knoten u ∈ V \S, dass c(S : {u})
maximal ist;
S = S ∪ {vi};
}
if (n = 2) then return Schnitt δ({vn});
else {
G´ = G nach Identifikation(vn-1, vn);
return min{MINCUT(G´), δ({vn})};
2
6
3
2
1
4
4
2
7
2
3
8
Der Algorithmus berechnet den minimalen
Schnitt.
Beweis:
z
Induktion über die Größe n der Knotenmenge.
z
z
n=2 9
n → n + 1:
ƒ
ƒ
Fall 1: min. cut ist vn-1-vn-cut
9 (Theorem 1)
Fall 2: Sonst. Induktionsannahme.
4
Laufzeit
z
z
z
Aufgabe
pro Iteration:
z
z
Übungsblatt
3
|V| extractMax-Operationen
|E| increaseKey-Operationen
Mit Fibonacci-Heap:
Vgl. Flüsse:
Aufgabe
4
Aufgabe
1
Aufgabe
5
Aufgabe
2
5