Effiziente Algorithmen Hartmut Klauck Universität Frankfurt SS

Flussberechnung nach Dinic Definition Ein Fluss heisst blockierend, wenn es auf jedem Pfad s nach t eine gesättigte Kante gibt, d.h. f(u,v)=C(u,v) Blockierende Flüsse müssen nicht maximal sein! Idee: erweitere um einen blockierenden Fluss, statt einen augmentierenden Pfad Hoffnung: weniger Iterationen

Dinics Algorithmus Starte mit f(u,v)=0 für alle u,v Iteriere: Bilde N f Bilde einen Teilgraphen L f, in dem alle Kanten (u,v) erfüllen: (s,v)= (s,u)+1 Finde einen blockierenden Fluss f in L f Setze f:=f+f

Dinic Noch zu zeigen: Wie werden blockierende Flüsse gefunden Zeit: O(m log n) Anzahl Iterationen: n-2 Wenn es keinen blockierenden Fluss mehr gibt, gibt es keinen augmentierenden Pfad mehr ) Korrektheit Damit erhalten wir einen Algorithmus, der in Zeit O(nm log n) maximale Flüsse berechnet.

Niveaunetzwerk Sei N f ein Restnetzwerk für einen Fluss f Das Niveaunetzwerk L f ist wie folgt definiert: V i sei die Knotenmenge in Distanz i von der Quelle E i seien die Kanten in N f, die von V i nach V i+1 laufen E= [ E i L f sei wie N f eingeschränkt auf Kanten in E L f kann durch Breitensuche berechnet werden

Blockierende Flüsse Wir betrachten blockierende Flüsse im Niveaunetzwerk L f zu einem Restnetzwerk N f f ist hierbei der bereits in vorherigen Iterationen berechnete Fluss

Einfaches Finden von block. Flüssen L sei ein Niveaunetzwerk In Zeit O(nm): Starte mit einem Fluss f(u,v)=0 für alle u,v Solange möglich: Finde einen Weg p von s nach t Sättige Weg, d.h. setze f(u,v):=f(u,v)+C f (p) für alle Kanten (u,v) auf dem Weg, f(v,u)=-f(u,v) entsprechend Entferne gesättigte Kanten auf p und verringere Kapazitäten der Kanten auf p sonst um C s (p) · m Iterationen, da jedesmal mindestens eine Kante gesättigt wird Kosten eines Durchlaufs? Tiefensuche kann O(m) kosten

Kosten der Berechnung block. Flüsse Wir verwenden eine amortisierte Analyse Berechnung der Wege durch Tiefensuche Jede einzelne Tiefensuche kann (m) dauern Idee: Wenn wir auf eine Sackgasse stossen, entfernen wir Kanten. Kosten pro entfernter Kante: O(1) Wenn wir also einen Weg finden, haben wir Kosten O(n) für den Weg plus der Kosten für entfernte Kante in Sackgassen Damit Gesamtkosten: O(mn) für Finden der Wege +O(m) für Entfernen von Sackgassen Amortisierte Analyse: Wir beschränken die durchschnittlichen Kosten pro Weg wenn m Wege gefunden werden Einige Wege sind teuer zu finden, dafür werden andere billiger

Kosten der Berechnung block. Flüsse Wir erhalten einen Algorithmus, der einen blockierenden Fluss in Zeit O(mn) berechnet

Anzahl Iterationen von Dinic Wir wollen zeigen, dass es nur n-2 Iterationen gibt Dadurch erhalten wir eine Laufzeitschranke von O(n 2 m) Behauptung: (s,t) steigt in jeder Iteration um 1 Daher nur n-2 Iterationen möglich

Anzahl Iterationen von Dinic Sei also (s,t)=k zu Beginn Ein blockierender Fluss sättigt alle Wege der Länge k Alle Wege der Länge k werden durch die Addition des blockierenden Flusses zerschnitten Es gibt allerdings neue Kanten, diese verlaufen aber nur von Level i+1 nach Level i, daher haben neue Wege mit solchen Kanten Länge k+2 mindestens Also sind kürzeste Wege mind. k+1 lang nach der Iteration.

Zusammenfassung: Wir erhalten einen Algorithmus zur Berechnung maximaler Flüsse mit Zeit O(n 2 m)

Schnellere Berechnung von blockierenden Flüssen Sei N ein Niveaunetzwerk (insbesondere ein Flussnetzwerk) Wir wollen einen blockierenden Fluss in Zeit O(m log n) berechnen. Dann ist die Gesamtlaufzeit von Dinic nur O(mnlog n)

Schnellere Berechnung von blockierenden Flüssen Wir unterhalten eine Datenstruktur zur Speicherung von Bäumen/Wäldern Knoten haben assoziierte Kosten Folgenden Operationen Maketree(v) Erzeuge einen Baum aus Knoten v mit Kosten 0 w = findroot(v) Finde Wurzel des Baumes von w (w,c) = mincost(v) Bestimme w: Knoten mit minimalen Kosten auf dem Weg von v zu seiner Wurzel mit Kosten c, w sei so nah an der Wurzel wie möglich addcost(v,c) addiere c zu den Kosten der Knoten auf dem Weg von v zu seiner Wurzel link(v,w) Verbinde v,w durch eine Kante v nach w, v sei dabei eine Wurzel cut(v) Teile den Baum von v durch Entfernen der Kante von v zu seinem Elternknoten Behauptung: eine solche Datenstruktur kann mit amortisierter Laufzeit O(log n) pro Operation implementiert werden

Algo für block. Flüsse Starte mit maketree(v) für alle v advance: v = findroot(s), wenn v=t : augment Wenn v keine ausgehende Kante hat: retreat Sonst: Wähle Kante (v, w) und : link(v,w) Setze Kosten von v auf Restkapazität der Kante (v,w) advance augment: (v,c) = mincost(s), addcost(s,-c) : delete delete: entferne Kante (v, (v)). Setze f(v, (v)) = C(v, (v)). cut(v) (v,c) = mincost(s). Wenn(c=0) : delete, sonst : advance retreat: (Alle Wege von v nach t sind blockiert) wenn (v=s) stop, fertig. Entferne alle Kanten (u,v) Wenn (v (u)) dann f(u,v) = 0. Sonst: (u, ) = mincost(u), f(u,v) = c(u,v) -, cut(u). advance.

Algo für block. Flüsse Klar: der Algorithmus stoppt nur, wenn ein blockierender Fluss gefunden ist Jede Kante wird höchstens einmal in den Wald eingefügt und höchstens einmal entfernt Die Anzahl Operationen der Datenstruktur sind proportional zur Anzahl Einfügungen/Entfernungen von Kanten Damit O(m) Operationen und Laufzeit O(m log n)

Min Cuts Wir betrachten nun das Min-Cut Problem Gegeben sei ein ungewichteter ungerichter Graph G Wir suchen eine (nichttriviale) Partition L,R der Knotenmenge, bei der die Anzahl kreuzender Kanten minimal ist Unterschied zu s-t Min-Cut

Ein randomisierter Ansatz Betrachte Multigraphen: es kann mehrere Kanten von u nach v geben Min-Cuts sind analog definiert Wähle eine Kante (u,v) zufällig, uniform aus allen Kanten Verschmelze Knoten u,v: entferne alle Kanten von u nach v alle Kanten u nach w oder v nach w werden beibehalten wir erhalten so einen neuen Multigraphen Stoppe wenn nur noch 2 Knoten übrig: diese definieren L,R

Ein randomisierter Ansatz Intuition: Die Verschmelzungen reduzieren die Min- Cut Grösse nicht n-1 Iterationen Ein kleinerer Cut hat eine bessere Wahrscheinlichkeit, dass keine Kante des Cuts verschmolzen wird