Berechnung maximaler Flüsse unter Vermeidung von

Jan-Philipp Kappmeier
Berechnung maximaler Flüsse
unter Vermeidung von
Residualnetzwerken
Diplomarbeit im Studiengang Informatik
21.01.2009 21.07.2009
INTERNE BERICHTE
INTERNAL REPORTS
COGA
Fakultät II
Technische Universität Berlin
Lehrstuhl XI
Fakultät für Informatik
Technische Universität Dortmund
Gutachter:
Prof. Dr. Martin Skutella
Prof. Dr. Petra Mutzel
GERMANY · D-44221 DORTMUND
Ich danke meiner Freundin Manuela Becker für das Korrekturlesen der Arbeit, sowie für jegliche
Unterstützung. Dirk Koesling, Ann-Christine Pozun und Lars Riedel danke ich für das
Korrekturlesen meiner Diplomarbeit, Daniel Plümpe und Melanie Schmidt danke ich für
zahlreiche Anmerkungen, interessante Diskussionen und ebenfalls fürs Korrekturlesen. Prof. Dr.
Martin Skutella danke ich für die Vergabe des spannenden Themas und der Betreuung der
Arbeit, sowie Prof. Dr. Petra Mutzel für die Zweitkorrektur. Ich danke der Arbeitsgrupe COGA
für interessante Kaeepausen im Café Nerdlich und das Ziehen von Zufallszahlen. Meinen Eltern
danke ich dafür, dass sie mir das Studium ermöglicht haben.
Inhaltsverzeichnis
1
Einleitung
1
2
Grundlagen
5
2.1
Lineare Programmierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5
2.2
Graphen und Netzwerke
. . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7
2.3
Das Max-Flow-Min-Cut-Theorem . . . . . . . . . . . . . . . . . . . . . . . .
13
2.4
Das abstrakte Graphmodell
16
3
Maximale Flüsse
3.1
3.2
4
5
. . . . . . . . . . . . . . . . . . . . . . . . . . .
21
Flussaugmentierende Verfahren
. . . . . . . . . . . . . . . . . . . . . . . . .
21
3.1.1
Das Ford-und-Fulkerson-Prinzip . . . . . . . . . . . . . . . . . . . . .
21
3.1.2
Algorithmus von Edmonds und Karp . . . . . . . . . . . . . . . . . .
24
Das Abstrakte-Fluss-Verfahren
. . . . . . . . . . . . . . . . . . . . . . . . .
28
3.2.1
Vorüberlegungen
. . . . . . . . . . . . . . . . . . . . . . . . . . . . .
28
3.2.2
Pfade nden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
32
3.2.3
Pfad zusammensetzen
. . . . . . . . . . . . . . . . . . . . . . . . . .
35
3.2.4
Der Algorithmus
. . . . . . . . . . . . . . . . . . . . . . . . . . . . .
39
Der AbstractMaxFlow-Algorithmus
41
4.1
Algorithmus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
41
4.1.1
Übertragung auf kantenbasierte Netzwerke . . . . . . . . . . . . . . .
41
4.1.2
Optimierung
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
54
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
58
4.2
Analyse
4.3
Empirische Ergebnisse
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Zusammenfassung und Ausblick
66
77
Notationsverzeichnis
78
Literaturverzeichnis
84
Sachverzeichnis
85
i
1 Einleitung
Das in dieser Arbeit behandelte Problem, einen maximalen Fluss zu berechnen, hat eine
lange Tradition. Bereits 1781 gab Monge eine mathematische Formulierung für
Transport-
probleme an [29]. Dabei geht es darum, Objekte von Orten, an denen sie angeboten werden,
zu Orten, an denen sie nachgefragt werden, zu verschicken. Es kann dabei mehrere mögliche Optimierungsziele geben. Auÿer dem Ziel, möglichst viel zu verschicken, kann das Ziel
sein, die Waren möglichst günstig oder schnell zu verschicken.
Graphen
spielen in vielen Anwendungen eine wichtige Rolle und können auch eingesetzt
werden, um Transportprobleme zu modellieren. Die auch heute noch wichtige Problemstellung, den Transport über ein Schienennetz zu optimieren [31], lässt sich ebenfalls als
Graphenproblem darstellen. Für eine eziente Organisation des Güterverkehrs ist es zweifellos wichtig, den Fluss zwischen verschiedenen Punkten im Netzwerk zu maximieren.
Harris und Ross [17] betrachteten, wie man ein solches Schienennetz möglichst leicht
durchtrennen kann, so dass zwei Städte nicht mehr miteinander in Verbindung stehen.
Durch diese Überlegungen angestoÿen entdeckten Ford und Fulkerson 1956 [10] ihr berühmtes Resultat: das Max-Flow-Min-Cut-Theorem, das besagt, dass in einem Netzwerk
der Wert eines maximalen Flusses dem eines minimalen Schnittes entspricht. Es wurde
unabhängig von Elias, Feinstein und Shannon [8] gefunden. Gleichzeitig haben Dantzig
und Fulkerson [5] einen auf dem Dualitätssatz für lineare Programme [30, Korollar 7.1g]
basierenden Beweis gefunden.
Flüsse haben auÿer der ursprünglichen Fragestellung vielfältige Anwendungen. Beim
Problem der maximalen Paarung
sollen jeweils zwei Elemente zweier disjuntker Mengen
zu einem Paar zusammengefasst werden. Jedes dieser Elemente hat dabei gewisse Einschränkungen, mit welchen Elementen der anderen Menge es ein Paar bilden kann. Dieses
Problem lässt sich als
bipartiter Graph modellieren und eine passende (maximale) Paarung
1
kann durch die Berechung eines maximalen Flusses bestimmt werden [34, Kapitel 4.4].
Ein weiteres Problem, das sich mit maximalen Flüssen lösen lässt, ist das
Problem.
Job-Zuteilungs-
Dabei gibt es Aufgaben mit verschiedenen Bearbeitungszeiten und Angestellte,
von denen bekannt ist, wer welche Aufgabe übernehmen kann. Das Ziel ist, für jeden Arbeiter festzulegen, wie lange er an welcher Aufgabe arbeitet, so dass alle Aufgaben in kürzester
Zeit fertiggestellt sind. Ein populäres Problem ist das
1
Meisterschaftsproblem, bei dem für
Dieses Problem wird auch Heiratsproblem genannt. Die Mengen entsprechen den Männern und Frauen.
Das Ziel ist, möglichst viele Ehen mit Partnern, die sich auch mögen, zu schlieÿen.
1
1 Einleitung
Abbildung 1.1: Das von Harris und Ross betrachtete Problem: wie lässt sich (militärisch) das Schienennetz der Sowjetunion möglichst ezient trennen, so dass der Osten und Westen
nicht mehr miteinander in Verbindung stehen. Das Schienennetz ist abstrakt als
Graph mit geschätzten Kapazitäten dargestellt.
eine Liga herausgefunden werden soll, ob ein bestimmter Verein noch Meister werden kann.
Mit einer
(0 : 1 : 2)-Punkteaufteilung,
die bis 1995 auch in der deutschen Fuÿballbundes-
liga angewandt worden ist, kann dieses Problem durch die Berechnung eines maximalen
Flusses gelöst werden[34, Kapitel 4.4].
Im Bereich der Netzwerküsse deckt die Forschung eine Vielzahl von Anwendungen ab,
für die Flüsse mit verschiedenen Eigenschaften benötigt werden. Wenn das Verschicken
von Gütern über bestimmte Kanten unterschiedliche Kosten verursacht, ist die Berechnung kostenminimaler Flüsse interessant.
Mehrgüterüsse
decken Szenarien ab, bei denen
verschiedene Güter nur von bestimmten Startpunkten zu bestimmten Endpunkten verschickt werden können. Eine besonders aktuelle Forschungsrichtung beschäftigt sich mit
dynamischen Flüssen, die bereits 1962 von Ford und Fulkerson in ihrem Buch über Flüsse
[11, Kapitel 3.9] erwähnt worden sind. In diesem Modell wird für das Durchlaufen einer
Kante eine gewisse Zeit benötigt. Dieses Modell ist zweifellos realistischer als das Standardmodell, aber auch deutlich schwieriger handzuhaben. Eine wichtige Anwendung ist
die Modellierung von Evakuierungsszenarien, in denen Zeit eine wichtige Rolle spielt. Eine
Einführung in dynamische Flüsse ndet sich in [32].
Angesichts dieser Vielzahl verschiedener Flussprobleme ist die Forschung an der grundlegenden Fragestellung, einen maximalen Fluss zu bestimmen, interessant. Nicht nur, um
das Problem schneller zu lösen, sondern auch, um grundlegende Einsichten in die Natur
und Struktur von Netzwerküssen zu gewinnen (wie zum Beispiel das Max-Flow-Min-CutTheorem).
2
Der erste Beweis des Max-Flow-Min-Cut-Theorems ist nicht konstruktiv und liefert keinen Algorithmus zur Berechnung von maximalen Flüssen (oder eines minimalen Schnittes). Als lineares Problem kann man einen maximalen Fluss (und Lösungen für alle Arten
von Transportproblemen) mit dem Simplex-Algorithmus [4] berechnen. Mit dem NetzwerkSimplex-Algorithmus gibt es eine auf Flussprobleme spezialisierte Variante des Algorithmus
[1, Kapitel 11].
Ford und Fulkerson veröentlichten 1957 [9] einen Algorithmus zum Berechnen maximaler Flüsse in gerichteten Netzwerken, der das nach ihnen benannte
begründete. Sie benutzten zum Berechnen
Rückwärtskante
Ford-Fulkerson-Prinzip
Residualnetzwerke, in denen zu jeder Kante eine
existiert. In solchen Netzwerken kann ein maximaler Fluss durch schritt-
weises Hinzufügen von
augmentierenden Pfaden berechnet werden. Während die erste Ver-
sion noch pseudopolynomielle Laufzeit hatte, wurden 1970 von Dinic [6] und 1972 von
Edmonds und Karp [7] verbesserte Varianten angegeben, die echt polynomielle Laufzeiten
haben. Auch später wurden weitere Verbesserungen angegeben, bis schlieÿlich mit [13] das
Push-Relabel-Verfahren aufkam, welches deutlich schnellere Berechnungen maximaler Flüsse erlaubt. Der Algorithmus von Ford und Fulkerson sowie der Algorithmus von Edmonds
und Karp werden in Abschnitt 3.1 beschrieben.
Homan verallgemeinerte 1974 das Max-Flow-Min-Cut-Theorem [20] zu einer Variante
für eine deutlich allgemeinere Klasse von Graphen. Es gibt für viele Situationen ähnliche
Theoreme, die bei passender Modellierung alle von diesem Satz abgedeckt werden können.
Der Beweis hat mit dem ursprünglichen Beweis von Ford und Fulkerson gemein, dass er
nicht konstruktiv ist. McCormick [27] fand einen Algorithmus, der in diesem Modell einen
maximalen Fluss in polynomialer Zeit berechnet, falls ein Orakel mit konstanter Laufzeit
benutzt wird. Im Gegensatz zu allen vorher erwähnten Algorithmen (abgesehen von linearen Programmen) nutzt dieser Algorithmus kein Residualnetzwerk. Diesen Algorithmus
beschreiben wir in Abschnitt 3.2.
Der Algorithmus von McCormick arbeitet mit Pfaden und nicht auf Kanten. Da er einen
Fluss schrittweise entlang von Pfaden ändert, arbeitet er aber nach Art des Ford-FulkersonPrinzips. Es ist das Ziel dieser Arbeit, einen pfadbasierten Algorithmus zu entwickeln, der
das Verhalten imitiert, aber ohne Residualnetzwerk auskommt. Ein solcher Algorithmus
wird in Abschnitt 4.1 vorgestellt. Kapitel 4.2 enthält eine Analyse des Algorithmus anhand
einiger Beispiele und liefert einige Möglichkeiten, wie die erste Variante verbessert werden
kann. Ein empirischer Vergleich der entwickelten Varianten mit herkömmlichen ussaugmentierenden Verfahren wird in Abschnitt 4.3 durchgeführt. Dazu benutzen wir verschiedene Instanzen, wie zum Beispiel die
RMFGEN-Instanzen, die Goldfarb und Grigoriadis beim
Vergleich des Algorithmus von Dinic mit dem Netzwerk-Simplex-Algorithmus [14] nutzten.
Dieser und weitere Generatoren wurden auch im Rahmen der ersten
DIMACS-Challenge
vorgestellt [21].
3
2 Grundlagen
2.1 Lineare Programmierung
Für die Behandlung des abstrakten Flussalgorithmus, der Flüsse in einer pfadbasierten
Darstellung verwendet, benötigen wir einige Grundlagen aus der linearen Programmierung,
die wir zunächst kurz angeben wollen. Es soll hier jedoch nicht in die Tiefe gegangen, sondern nur die im Verlauf der Arbeit benötigten Fakten angegeben werdens. Weiterführende
Informationen nden sich zum Beispiel in [30].
2.1.1 Denition (Lineares Programm).
und
c ∈ Rn .
Ein lineares Programm
Variablen
n
X
(P )
m, n ∈ N, A = (a)ij ∈ Rm×n , b ∈ Rm
Seien
besteht aus
linearen Ungleichungen
m
über
n
aij xj = ai1 x1 + ai2 x2 + · · · ain xn ≤ bi
j=1
für
i ∈ {1, 2, . . . , m}.
heiÿt
Ein nichtnegativer Vektor
zulässige Lösung. x
c2 x02 + · · · + cn x0n
ist eine
x ∈ Rn≥0 ,
optimale Lösung,
für alle zulässigen Lösungen
x0
falls
der die Unleichungen erfüllt,
c1 x1 + c2 x2 + · · · cn xn ≥ c1 x01 +
gilt. Wir schreiben das lineare Programm
auch als
(P ) maximiere cT x
s.t.
Ax ≤ b
x ≥ 0
Durch Multiplikation der Nebenbedinungen
0
eine Form A x
≥
b0 gebracht werden. Dabei ist
Ax ≤ b
A0
mit
= −A
(−1)
0
und b
kann das Problem in
= −b.
Wir können also
beide Ungleichungen nutzen. Zu einem linearen Programm gibt es ein sogenanntes duales
Programm:
2.1.2 Denition (Duales Programm).
Sei ein lineares Programm gegeben, das
cT x
duale Programm (D) ist ebenfalls
ein lineares Programm und besteht aus den linearen Ungleichungen
unter der Bedingung
Ax ≤ b
m
X
maximiert. Das zugehörige
aij yi = a1j y1 + a2j y2 + · · · amj ym ≥ cj
i=1
5
2 Grundlagen
für
j ∈ {1, 2, . . . , n}.
heiÿt
Ein nichtnegativer Vektor
y ∈ Rm
≥0 ,
der die Ungleichungen erfüllt
zulässige duale Lösung. y ist eine optimale duale Lösung, falls b1 y1 +b2 y2 +· · · bm ym ≤
0 für alle zulässigen dualen Lösungen
b1 y10 +b2 y20 +· · ·+bm ym
y0
gilt. Wir schreiben das duale
Programm auch als
(D) minimiere
bT y
s.t. AT y ≥ c
y ≥ 0
Das duale Programm ist selbst wieder ein lineares Programm (mit umgedrehten Ungleichungen). Das duale Programm eines dualen Programmes ist wieder das ursprüngliche
Programm.
Eine optimale Lösung eines linearen Programms kann mit dem Simplex-Algorithmus berechnet werden. Er ist praktisch ezient, hat jedoch im schlechtesten Fall eine exponentielle
Laufzeit. 1979 hat Ha£ijan [16] mit der Ellipsoidmethode einen polynomiellen Algorithmus
angegeben, der aber praktisch zu inezient ist. 1984 veröentlichte Karmakar [22] mit
der
Innere-Punkte-Methode
einen weiteren polynomiellen Algorithmus zum Lösen linearer
Programme, der durch weitere Verbesserungen, wie zum Beispiel [28], konkurrenzfähig zum
Simplex-Verfahren ist.
Der
Dualitätssatz für lineare Programme
liefert eine wichtige Eigenschaft von linearen
und den zugehörigen dualen Programmen: Der Wert einer optimalen Lösung für beide
Programme stimmt überein, falls eine Lösung existiert [30, Korollar 7.1g]. Unabhängig
vom Wert kann anhand des
komplementären Schlupfes festgestellt werden, ob eine optimale
Lösung gefunden worden ist.
2.1.3 Satz (Komplementärer Schlupf). Seien x eine zulässige Lösung für ein lineares
Programm
(P ) maximiere cT x
s.t.
Ax ≤ b
x ≥ 0
und y eine zulässige Lösung für das zugehörige duale Programm
(D) minimiere
bT y
s.t. AT y ≥ c
y ≥ 0
gegeben. Dann sind x und y optimale Lösungen, falls für alle i ∈ {1, 2, . . . , m}
yi · (Ai x − bi ) = 0
(2.1)
(cj − y T ATj ) · xj = 0
(2.2)
und für alle j ∈ {1, 2, . . . , n}
gilt.
6
2.2 Graphen und Netzwerke
Beweis.
Ein Beweis ndet sich zum Beispiel in [24, Korollar 3.23].
2.2 Graphen und Netzwerke
Wir beginnen mit der Netzwerküssen zugrundeliegenden Struktur, den Graphen und speziell den Netzwerken. Auf diesen Strukturen aufbauend denieren wir dann einen
2.2.1 Denition (Graph).
Seien
V = {1, 2, . . . , n} eine endliche Menge und E ⊆ V × V .
Knoten, die Elemente aus E
ist G := (V, E) ein gerichteter Graph.
Die Elemente aus
Falls
E
V
heiÿen
heiÿen
gerichtete Kanten. Dann
keine Menge ist, sondern eine Multimenge mit Elementen aus
Elemente aus
E
Multigraph.
gerichtete Mehrfachkanten,
2.2.2 Denition.
henden Kanten
Sei
von
v
G = (V, E)
Fluss.
in diesem Fall heiÿt
ein Graph und
v ∈ V.
V ×V,
G = (V, E)
heiÿen die
gerichteter
Dann ist die Menge der
einge-
deniert als
v − := {e ∈ E | e = (w, v) ∧ w ∈ V },
analog ist die Menge der
ausgehenden Kanten
von
v
deniert als
v + := {e ∈ E | e = (v, w) ∧ w ∈ V }.
Netzwerke sind spezielle Graphen, die besonders ausgezeichnete Knoten enthalten:
2.2.3 Denition (Netzwerk).
Funktion
c : E → R≥0
Sei
G = (V, E)
weise jeder Kante aus
Quelle s ∈ V und Senke t ∈ V
(V, E, s, t, c) ein Netzwerk.
Die
ein gerichteter Graph (Multigraph). Die
G
eine nichtnegative
Kapazität c(e)
seien zwei ausgezeichnete Knoten. Dann ist
zu.
N :=
Sofern nicht anders gesagt, beschränken wir uns im Folgenden auf einfache Graphen
ohne Multikanten. Sowohl die folgende Denition von Flüssen als auch die betrachteten
Algorithmen lassen sich ohne Weiteres direkt auf Multigraphen erweitern. Andersherum
lassen sich Mehrfachkanten zu einer Kante zusammenfassen, die als Kapazität die Summe
der Einzelkapazitäten erhält. Dies gilt aber nicht für alle Flussprobleme.
2.2.4 Denition (Kantenuss).
E → R≥0 ,
Ein Fluss auf einem Netzwerk
N
ist eine Funktion
φ:
die folgende Bedingungen erfüllt:
∀ e ∈ E : φ(e) ≤ c(e)
(2.3)
7
2 Grundlagen
∀ v ∈ V \ {s, t} :
X
X
φ(e) =
e∈v −
φ(e)
(2.4)
e∈v +
Einhaltung der Kapazitäten, Bedingung (2.4) fordert Flusserhaltung an den Knoten und heiÿt auch Kirchho'sche Regel.
Für einen Knoten v ∈ V und einen Fluss φ denieren wir den eingehenden Fluss als
Bedingung (2.3) fordert die
vin (φ) :=
X
φ(e)
e∈v −
und den
ausgehenden Fluss
als
vout (φ) :=
X
φ(e).
e∈v +
Wenn
φ(e) = c(e)
saturiert.
Der Wert
ist, das heiÿt, die Kapazität von
eines Flusses
e
wird ausgeschöpft, so heiÿt
e
φ ist deniert als der aus der Senke herausieÿende Fluss abzüg-
lich des wieder zurückieÿenden Flusses:
val(φ) := sout (φ) − sin (φ) =
X
φ(e) −
e∈s+
Der Fluss
φ ≡ 0,
X
der auf jeder Kante den Wert Null hat, heiÿt
2.2.5 Bemerkung.
φ(e).
e∈s−
Nulluss.
Aufgrund der Flusserhaltung (2.4) an allen Knoten auÿer der Quelle
und Senke kommt Fluss, der nicht wieder zur Quelle zurückieÿt an der Senke an. Der
Wert eines Flusses entspricht also auch dem in die Senke hereinieÿenden Flusses. Das
heiÿt es ist
val(φ) = tin (φ) − tout (φ).
2.2.6 Denition (Maximaler Fluss).
heiÿt
Sei
N = (V, E, s, t, c)
maximal, falls für jeden anderen Fluss ψ
Das
Problem des maximalen Flusses
gilt, dass
ein Netzwerk. Ein Fluss
val(ψ) ≤ val(φ)
φ
ist.
ist die Suche nach einem solchen maximalen Fluss
in einem beliebigen Netzwerk. Folgendes lineares Programm ndet einen maximalen Fluss
(vgl. [5] und [24, Kapitel 8.1]):
max
P
φe −
P
e∈v +
φe
e∈ s−
e∈s+
s.t.
P
φe −
P
φe = 0
∀ v ∈ V \ {s, t}
φe ≤ c(e)
∀e ∈ E
φe ≥ 0
∀e ∈ E
e∈v −
Da der Nulluss immer eine gültige Lösung ist und der maximal erreichbare Wert durch
die Summe aller Kapazitäten nach oben beschränkt ist, gibt es immer eine optimale Lösung.
Eine Berechnung ist mit den in Abschnitt 2.1 erwähnten Algorithmen möglich, es gibt
jedoch deutlich bessere kombinatorische Algorithmen.
8
2.2 Graphen und Netzwerke
2.2.7 Denition (Pfad und Kreis).
Seien
G = (V, E)
ein gerichteter Graph und
P :=
Weg falls für alle i ∈ {1, 2, . . . , n−
1} das (vi , vi+1 ) eine Kante in E ist. Falls e = (vi , vi+1 ) für ein i ist, sagen wir e liegt auf
(v1 , v2 , . . . , vn ) ⊆ V n
P
und schreiben
v1
heiÿt
eine Sequenz von Knoten.
P
ist ein
e ∈ P.
Startknoten
und
vn
Endknoten
von
P.
Falls die Sequenz keine doppelten Knoten enthält, das heiÿt für alle
Pfad von v1
einem Graphen nennen wir x-y -Pfad.
gilt
i 6= j ⇒ vi 6= vj ,
e = (vi , vi+1 )
Sei
Kanten
von
(vj , vj+1 )
ist
P
ein
nach
eine Kante in einem Pfad
links
von
e
und für
vn .
P.
Einen Pfad von
Dann liegen für
j ∈ {i + 1, . . . , n − 1}
i, j ∈ {1, 2, . . . , n}
x∈V
nach
y∈V
j ∈ {1, . . . , i − 1}
die Kanten
(vj , vj+1 )
in
die
rechts
e.
Ein Pfad, dessen Startknoten und Endknoten gleich sind, heiÿt
i, j ∈ {1, 2, . . . , n − 1}
gilt
i 6= j ⇒ vi 6= vj
und es ist
Kreis.
Das heiÿt für
v1 = vn .
Ein Pfad ist ein Weg, der keine zwei Knoten (und damit auch Kanten) doppelt enthält.
Wege sind als Knotensequenzen deniert. Da jedoch immer eine Kante zwischen zwei aufeinanderfolgenden Knoten des Weges im Graph vorhanden sein muss, kann ein Weg auch
mit den Kanten, die auf ihm liegen, identiziert werden. Von dieser Möglichkeit werden
wir im Folgenden Gebrauch machen.
Wir wollen nun einen Begri zum Ändern eines Flusses einführen und zeigen, unter
welchen Umständen der Fluss gültig bleibt. Ein Fluss kann entlang von Pfaden und Kreisen
problemlos verändert werden und wir werden sehen, dass er sogar nur aus Pfaden aufgebaut
werden kann.
2.2.8 Denition (Augmentierung).
tigen Fluss
Für
φ
δ∈R
und
M ⊆E
eine Teilmenge der Kanten.
sei eine neue Funktion
φ0 (e) :=
Wenn
φ0
positives
heiÿt
M
φ0 : E → R deniert als
(
φ(e) + δ
e∈M
φ(e)
ein gültiger Fluss ist, sagen wir
δ>0
auch
N = (V, E, s, t, c) ein Netzwerk mit einem gül-
Sei
φ
sonst
wird entlang
sagen wir auch, der Fluss wurde um
augmentierender Pfad.
Wenn ein Fluss entlang eines
s-t-Pfades
δ
M
um
δ
zu
φ0
geändert. Für
augmentiert. Falls M
ein Pfad ist,
augmentiert wird, gilt die Kirchho 'sche Regel
(2.4) weiterhin. Es kann jedoch passieren, dass die Kapazitäten überschritten werden; falls
der Fluss verringert wird, muss darauf geachtet werden, dass er nichtnegativ bleibt.
2.2.9 Lemma (Augmentierende Pfade und Kreise). Sei N = (V, E, s, t, c) ein Netzwerk, φ ein gültiger Fluss auf N und M ein s-t-Pfad oder ein Kreis.
Sei δ ∈ R so gewählt, dass ∀ e ∈ M : δ ∈ [−φ(e), c(e) − φ(e)] gilt.
9
2 Grundlagen
Dann kann φ entlang M um δ geändert werden und bleibt dabei gültig. Falls M ein Kreis
ist ändert sich der Wert des Flusses nicht. Ansonsten ändert sich der Wert um δ .
Beweis.
Für jede Kante
Für positives
δ
ist
e∈M
werden die Kapazitäten nach der Änderung eingehalten:
φ(e) + δ ≤ φ(e) + c(e) − φ(e) = c(e);
falls
δ
negativ ist, gilt
φ(e) + δ ≥
φ(e) + (−φ(e)) = 0.
Es bleibt zu zeigen, dass die Kirchho 'sche Regel gilt. Sei
und
g := (v, w)
eine ausgehende Kante eines Knotens
f := (u, v)
v ∈ M.
Da
v
eine eingehende
auf einem Pfad oder
Kreis liegt, gibt es genau eine eingehende und eine ausgehende Kante von
v
in
M.
Dies
gilt, weil Kreise sich nach Denition nicht schneiden dürfen. Für den nach Denition 2.2.8
entstehenden Fluss
φ0
gilt dann
Def
vin (φ0 ) =
X
φ0 (e)
e∈v −
X
=
φ0 (e) + φ0 (f )
e∈v − \{f }
Def
X
=
φ(e) + φ(f ) + δ
e∈v − \{f }
=
X
φ(e) + δ
e∈v −
Def
= vin (φ) + δ
für den in
v
ieÿenden Fluss und
Def
X
vout (φ0 ) =
φ0 (e)
e∈v +
X
=
φ0 (e) + φ0 (f )
e∈v + \{f }
Def
X
=
φ(e) + φ(f ) + δ
e∈v + \{f }
X
=
φ(e) + δ
e∈v +
Def
= vout (φ) + δ
für den aus
v
ausieÿenden Fluss. Sei
v∈
/ {s, t}
falls
M
ein
s-t-Pfad
ist. Dann gilt
vin (φ0 ) = vout (φ0 )
⇔ vin (φ) + δ = vout (φ) + δ
⇔ vin (φ) = vout (φ)
und die Flusserhaltung (2.4) ist erfüllt.
Eine Änderung des Flusses entlang Kreisen ändert den Flusswert nicht, da die Rechnung
für Kreise auch an der Quelle und der Senke gültig ist. Das Ändern des Flusses entlang
10
2.2 Graphen und Netzwerke
eines
s-t-Pfades
ändert jedoch auch den Flusswert, denn in diesem Fall hat
ausgehende Kante, aber keine eingehende Kante auf
δ
höheren Wert:
M.
s
genau eine
Der neue Fluss hat also einen um
val(φ0 )
Def
= sout (φ0 )
= sout (φ) + δ
= val(φ) + δ
Wir wollen nun zeigen, dass ein Fluss allein durch Fluss auf Pfaden und Kreisen bestimmt
ist, dass man sogar die Kreise auslassen kann. Eine solche Darstellung eines Flusses heiÿt
Dekomposition.
2.2.10 Denition (Fluss-Dekomposition).
nem Fluss
φ.
N = (V, E, s, t, c)
ein Netzwerk mit ei-
Es sei
P := {P ⊆ P(E) | P
die Menge aller
s-t-Pfade
ist ein
die Menge aller Kreise in
(xP )P ∈P∪C
s-t-Pfad
in
N}
und
C := {C ⊆ P(E) | C
Eine Folge
Sei
ist ein Kreis in
N}
N.
ist eine
Fluss-Dekomposition, falls xP ≥ 0 ist und
X
∀e ∈ E :
xP = φ(e)
(2.5)
P ∈P∪C:e∈P
gilt.
Falls zusätzlich
xP = 0
für alle Kreise
P ∈C
gilt, heiÿt
(xP )
Pfad-Dekomposition.
Das folgende Fluss-Dekompositions-Theorem ndet sich zum Beispiel in [11]. Der folgende Beweis orientiert sich an [24, Theorem 8.8].
2.2.11 Satz (Fluss-Dekomposition). Sei N
ein Netzwerk mit Fluss φ,
P die Menge aller s-t-Pfade und C die Menge aller Kreise in N .
Dann existiert eine Fluss-Dekomposition (xP )P ∈P∪C und die Anzahl der positiven Pfade
P mit xP > 0 ist maximal C ≤ |E|, falls es C Kanten mit positivem Fluss gibt.
Beweis.
= (V, E, s, t, c)
Wir beweisen die Aussage mittels Induktion über die Anzahl der Kanten
C
mit
echt positivem Fluss.
Sei
C = 0,
das heiÿt es gibt keine ussführende Kante. Dann ist die Menge der Pfade
und Kreise die Fluss führen leer und es gilt
Sei nun
{t, v0 }.
C > 0
Falls
w0
und
in
E0
i := 0.
Es sei
xP = 0
e0 := (v0 , w0 )
für jeden Pfad
P ∈ P ∪ C.
eine Kante mit
φ(e) > 0
und
E0 :=
liegt, brechen wir ab. Andernfalls gibt es wegen (2.4) eine Kante
11
2 Grundlagen
ei+1 := (wi , wi+1 ) mit φ(ei+1 ) > 0. Wir denieren dann Ei+1 := Ei ∪ {wi }, setzen i := i + 1
und fahren mit dem Test
wi ∈ Ei
fort. Da die Mengen
werden, bricht das Verfahren nach spätestens
Wir führen nun das gleiche Verfahren von
j := 0 und e00 := (v0 , w0 ). Falls vj ∈ Ej0
e0j+1 := (vj+1 , vj )
mit
fahren fort bis für ein
nach spätestens
Falls
j
|E|
Schritten ab.
v0
ausgehend durch. Es sei
i
immer gröÿer
E00 := {s, w0 },
liegt brechen wir ab. Andernfalls gibt es eine Kante
0
:= Ej0 ∪ {vj }
Ej+1
Es sei nun
und
j := j + 1.
Wir
0
der Knoten vj in Ej enthalten ist; auch dieses Verfahren bricht
Schritten ab.
gefunden. Sei
gemäÿ Lemma 2.2.9 um
gilt
für wachsendes
vj = s und wi = t gelten, wurde ein s-t-Pfad gefunden, andernfalls wurde ein Kreis
Ei ∪ Ej0
in
|E|
φ(e0j+1 ) > 0.
Ei
φ(e) = δ ,
P
der so gefundene Pfad oder Kreis. Dann können wir den Fluss
δ := − min{φ(e) | e ∈ P }
ändern. Für mindestens eine Kante
die Anzahl der Kanten mit echt positivem Fluss verringert sich um
e
c > 0.
Nach Induktionsvoraussetzung gibt es eine Fluss-Dekomposition des entstandenen Flusses
φ0
mit höchstens
C −c
positiven Pfaden. Zusammen mit
damit auch eine Fluss-Dekomposition von
φ
P
mit höchstens
und dem Wert
C
xP := δ
gibt es
ussführenden Pfaden oder
Kreisen.
2.2.12 Korollar (Pfaddekomposition). Sei
ein Netzwerk mit Fluss
φ, P die Menge aller s-t-Pfade und C die Menge aller Kreise in N .
Dann existiert eine Pfad-Dekomposition (xP )P ∈P , das heiÿt xP = 0 für P ∈ C.
Beweis.
N = (V, E, s, t, c)
(xP 0 )P 0 ∈P∪C . Sei C
Nach Satz 2.2.11 existiert eine Fluss-Dekomposition
mit Flusswert
xC > 0.
Deniere dann
mindestens Fluss in Höhe von
xC
auf
e
δ := −xC .
ist
0 < δ ≤ φ(e),
da
ieÿt.
C
Wird der Fluss entlang eines Kreises
seinen Wert und anschlieÿend gilt
e ∈ C
Für alle
ein Kreis
um
xC = 0.
δ
verändert, behält er nach Lemma 2.2.9
Dieses Verfahren kann nacheinander für alle
Kreise mit echt positivem Flusswert durchgeführt werden.
2.2.13 Lemma. Es sei N = (V, E, s, t, c) ein Netzwer und P die Menge der s-t-Pfade in
N.
Jedem Pfad P sei ein Fluss xP zugewiesen und es gelte
X
∀e ∈ E :
xP ≤ c(e).
P ∈P:e∈P
Dann kann aus diesen Pfaden ein Fluss mit Wert
Beweis.
P
xP
P ∈P
in N konstruiert werden.
P ∈ P. Sei φ der aktuelle
P
gilt φ(e) + Xp ≤
XP 0 +
Wir augmentieren den Fluss nacheinander für jeden Pfad
Fluss, zu Beginn ist
φ≡0
der Nulluss. Nach Voraussetzung
P 0 6=P
XP =
Da
P
≤ c(e). Nach Lemma 2.2.9 kann der Fluss damit um xP
P ∈P:e∈P
P
nur s-t-Pfade augmentiert werden, ist val(φ) =
φ(e). Für
augmentiert werden.
jeden hinzugefügten
e∈s+
Pfad wurde aber der Fluss auf einer von
ist insgesamt
val(φ) =
P
e∈s+
12
φ(e) =
P
P ∈P
s
xP .
ausgehenden Kante genau um
xP
erhöht, also
2.3 Das Max-Flow-Min-Cut-Theorem
2.3 Das Max-Flow-Min-Cut-Theorem
2.3.1 Denition (Schnitt).
heiÿt
N = (V, E, s, t, c)
Sei
trennende Menge, falls in E \ E 0
S ⊆E
Eine trennende Menge
s-t-Pfad
kein
Schnitt,
heiÿt
falls
ein Netzwerk. Eine Menge
E0 ⊆ E
mehr enthalten ist.
S
keine echte Teilmenge enthält, die
trennend ist.
Der Wert eines Schnittes
falls
val(S) ≤ val(S 0 )
S
val(S) :=
ist deniert als
für alle Schnitte
S0
P
e∈S
c(e). Der Schnitt heiÿt minimal,
ist.
Ein Schnitt mit minimalem Wert beschreibt eine Engstelle im Netzwerk, die damit
auch den maximalen Fluss beschränkt.
2.3.2 Lemma. Sei N = (V, E, s, t, c) ein Netzwerk, S ein Schnitt und φ ein Fluss.
Dann ist der Wert des Flusses durch val(S) nach oben beschränkt.
Beweis.
Es ist
Ein Schnitt
S
teilt die Knotenmenge des Netzwerks in zwei disjunkte Teilmengen.
Vs := {v ∈ V | ∃ s-v -Pfad
Vt := V \Vs
in
E \ S}
die Menge der von
die Menge der Knoten, von denen
inzidente Knoten beide in
St
s
erreichbaren Knoten und
t erreichbar ist. In S
liegt keine Kante, deren
liegen, da nach Entfernen dieser Kante
S
trennend bliebe.
S
ist aber minimal.
Wir nehmen an, dass keine der Kanten in
s−
Fluss führt. Dies kann nach Lemma 2.2.9
immer erreicht werden, indem der Fluss auf Kreisen auf 0 gesetzt wird. Dann gilt
val(φ) =
X
φ(e)
e∈s+
=
X
φ(e) −
X
φ(e)
e∈s−
e∈s+
An allen Knoten auÿer der Senke gilt Flusserhaltung, auÿerdem ist
Summe also auf alle Knoten in
Vs
X

X

v∈Vs
Wir können die
erweitern.

=
t∈
/ Vs .
e∈v +
φ(e) −
X
φ(e)
e∈v −
13
2 Grundlagen
Flusswerte für Kanten
e = (v, w)
gezählt und in der Summe über
mit
w−
v, w ∈ Vs
werden einmal in der Summe über
abgezogen. Wenn wir sie entfernen, ändert sich der
Wert der Summe nicht. Es bleiben dabei nur Kanten übrig, bei denen entweder
Vs
in
v+
v
oder
w
liegen, aber nicht beide Knoten.
X
=
X
φ(e) −
X
= val(S) −
φ(e)
e=(v,w):v ∈V
/ s ,w∈Vs
e=(v,w):v∈Vs ,w∈V
/ s
φ(e)
(2.6)
e=(v,w):v ∈V
/ s ,w∈Vs
≤ val(S)
Wir wollen nun das
Max-Flow-Min-Cut-Theorem
φ
tigen. Wir werden im Folgenden nur Flüsse
beweisen, wozu wir ein Lemma benö-
betrachten, die nur aus Pfaden bestehen.
Dies ist möglich, da es nach Satz 2.2.12 zu jedem Fluss eine Pfad-Dekomposition gibt, in
der nur auf
s-t-Pfaden
Fluss ieÿt. Sei
P := {P1 , . . . , Pp }
die Menge der verschiedenen
Pfade im Netzwerk. Damit können wir einen Fluss als Punkt
wir der
j -ten
x ∈
s -t
Rp darstellen, indem
Koordinate den Wert des entsprechenden Pfades in der Pfad-Dekomposition
zuweisen.
2.3.3 Bemerkung.
Da
φ1
und
φ2
Seien
φ1
und
φ2
zwei Flüsse. Dann ist
nichtnegativ sind, ist auch
φ
φ := αφ1 + (1 − α)φ2
nichtnegativ. Die Kapazitäten werden wegen
φ(e) = αφ1 (e) + (1 − α)φ2 (e) ≤ αc(e) + (1 − α)c(e) = c(e)
An jedem Knoten
X
e∈v −
φ(e) =
X
v ∈ V \ {s, t}
αφ1 (e) + (1 − α)φ2 (e) = α
X
für jede Kante
X
φ1 (e) + (1 − α)
e∈v −
φ1 (e) + (1 − α)
e∈v +
e
eingehalten.
gilt wegen
e∈v −
=α
ein Fluss.
X
φ2 (e) =
e∈v +
die Kirchho 'sche Regel. Auÿerdem gilt
X
φ2 (e)
e∈v −
X
αφ1 (e) + (1 − α)φ2 (e) =
e∈v +
val(φ) = val
da der Wert eine lineare Funktion ist. Falls
φ1
und
X
φ(e)
e∈v +
1
2 (φ1
+ φ2 ) = 12 (val(φ1 ) + val(φ2 )),
φ2
den gleichen Wert haben, gilt
val(φ) = val(φ1 ) = val(φ2 ).
Damit sind sowohl die Menge aller Flüsse im
Rp als auch die Menge der maximalen Flüsse
konvex. Wir können also Durchschnitte von Flüssen bilden und Durchschnitte maximaler
Flüsse bleiben maximal. Mit Induktion kann das Gezeigte auf Summen von
n
Flüssen
erweitert werden. Da die Menge aller Flüsse durch die Kapazitäten beschränkt ist, nimmt
die lineare Wertfunktion ein Maximum auf dieser Menge an.
Wir beweisen zunächst eine Hilfsaussage und anschlieÿend das Max-Flow-Min-Cut-Theorem. Das hier gewählte Vorgehen entspricht dem Beweis aus [10] eingeschränkt auf gerichtete Graphen.
14
2.3 Das Max-Flow-Min-Cut-Theorem
2.3.4 Lemma. Die Mengen
ist saturiert in jedem maximalen Fluss}
und L∗ := {e = (v, w) ∈ S ∗ | ∃ maximaler Fluss φ, Pfad P = (s = v0 , v1 , . . . , vn = v) :
∀ i ∈ {1, 2, . . . , n} : φ((vi−1 , vi )) < c((vi−1 , vi ))} sind trennend.
Beweis.
S ∗ := {e ∈ E | e
Wir zeigen zunächst durch einen Widerspruch, dass
gebe in einem Netzwerk mit maximalem Fluss einen Pfad
so dass keine der Kanten von
P
S∗
trennende Menge ist. Es
P := (s = v0 , v1 , . . . , vn = t),
∗
in S liegt. Nach Denition von
S∗
gibt es für jede Kante
ei := (vi−1 , vi ) ∈ P einen maximalen Fluss xi , der ei nicht saturiert.
n
1 P
xi . x ist maximal und saturiert keine Kante ei . Dann
Es sei x :=
n
kann der Fluss
i=1
auf
P
erhöht werden, was ein Widerspruch ist.
Wir zeigen nun, dass
L∗
trennend ist. Sei
P
ein beliebiger Pfad, der keine Kante aus
enthält. Wie gezeigt liegt mindestens eine Kante von
Kanten. Für jede links von
der
ei
ek
auf
P
liegende Kante
S.
ek ∈ P
P
in
ei
gibt es einen maximalen Fluss
Sei
L∗
die linkeste dieser
xi ,
nicht saturiert.
x :=
1
k−1
k−1
P
xi der Durchschnitt dieser Flüsse. Die Kanten
i=1
∗
saturiert, aber et ist saturiert und liegt damit in L .
Sei
e1
bis
ek−1
sind nicht
2.3.5 Satz (Max-Flow-Min-Cut [10]). Sei N = (V, E, s, t, c) ein Netzwerk, φ ein Fluss
und S ein Schnitt.
Dann ist φ genau dann ein maximaler Fluss und S ein minimaler Schnitt, falls val(φ) =
val(S) gilt.
Beweis.
Wir zeigen zunächst, dass kein positiver Pfad mehr als eine Kante aus der Men-
∗
ge L aus Lemma 2.3.4 enthalten kann. Sei
Dekomposition) und
liegen beide in
L∗ .
ein maximaler Fluss (als Pfad-
Sei
ei
links von
ej
x1P > 0.
∗
Da ej in L liegt, gibt es einen maximalen Fluss x2 und einen Pfad
linkeste saturierte Kante ist (dies impliziert ei ∈
/ P 0 ). Es sei δ := min{ek
0
das Minimum der freien Kapazitäten der Kanten auf P .
Wert von
P
ei , ej ∈ P
x1 ∈ Rp
1
2 x1P
xP ≥
> 0
verringert und auf
der
ei
Sei
Fluss
der als Mittel von
x1
der Wert des Flusses auf
xP 0
um
min{xP , δ}
und
P.
x2
P 0,
auf dem
und der
| ek ∈
P 0}
ej
>0
entstehende maximale Fluss. Es ist
Wenn der Fluss auf
xP
um
min{xP , δ}
erhöht wird, entsteht ein Fluss mit gleichem Wert,
nicht mehr saturiert. Dies ist ein Widerspruch zu
T
P
sei
x := 21 (x1 + x2 )
Sei
auf
ei ∈ L∗ .
eine beliebige trennende Menge. Es ist nach Lemma 2.3.2
val(T ) ≥ val(φ) für jeden
φ.
Wenn die Kapazitäten der Kanten aus
jeder
s-t-Pfad
auch
val(φ) ≤ val(L∗ )
L∗
summiert werden, wird, wie gerade gezeigt,
genau einmal getroen. Da nach Lemma 2.3.4
für jeden Fluss
L∗
trennende Menge ist, gilt
φ.
∗
Insgesamt folgt, dass L ein minimaler Schnitt ist und ein maximaler Fluss den selben
Wert hat.
15
2 Grundlagen
L∗
Aus dem Beweis des Lemmas folgt, dass
Pfad zusammensetzt. Die Menge
L∗
sich aus den linkesten Kanten in
heiÿt daher auch
S∗
für jeden
linkester Schnitt [15]. Analog kann
rechtesten Schnitt denieren.
∗
man über die Menge der rechtesten Kanten aus S einen
In [11, Kapitel 1.5] erklären Ford und Fulkerson, dass die beiden Schnitte genau dann
2
übereinstimmen, wenn der minimale Schnitt eindeutig ist .
2.4 Das abstrakte Graphmodell
Ein deutlich abstrakteres Modell als das Standardgraphmodell nach 2.2.1 führt Homan in
[20] ein. Das Modell der abstrakten Graphen ist pfadbasiert, wobei es jedoch in der Lage
ist, die unterschiedlichsten Arten von Flüssen in einem Modell darzustellen.
2.4.1 Denition (Abstrakter Graph).
Teilmenge der Elemente
P ⊆E
heiÿt
Sei
E
eine endliche Menge von
Elementen. Eine
Pfad, P ⊆ P(E) sei die Menge der Pfade und es sei
∅ ∈ P.
Auf jedem Pfad
Elemente
e, f ∈ P
beziehungsweise
f
Falls zwei Pfade
P
sei eine lineare Ordnung
gelte entweder
rechts
P
Q
oder
seiner Elemente deniert. Für zwei
f <P e.
Im Fall
e <P f
e
liegt
links
von
f
e.
von
und
e <P f
<P
ein Element
e∈P ∩Q
gemeinsam haben, sei die
menge (P, e, Q) deniert als
Kreuzungs-
(P, e, Q) := {f ∈ E | f ∈ P ∧ f <P e} ∪ {e} ∪ {f ∈ E | f ∈ Q ∧ e <Q f }.
Die Funktion
P, Q
und
r : P → N0
bestimme für jeden Pfad eine nichtnegative Zahl, so dass für
e
max{r(R) | R ∈ (P, e, Q)} + max{r(S) | S ∈ (Q, e, P )} ≥ r(P ) + r(Q)
gilt, dabei ist
Dann heiÿt
(2.7)
r(∅) := 0.
G := (E, P)
abstrakter Graph.
Die Denition ist sehr allgemein gehalten und hat in dieser Form fast keine Einschränkungen. Es ist durchaus möglich, dass zwei Elemente
auf
P
und rechts von
schneidende Pfade
P
und
sich schneiden, liegen und dabei
e
Für sich in einem Element
(P, e, Q) die Elemente von P
von
Q
nach
e
(bezüglich
e
links von
f
e, f ∈ P ∪ Q
Q
sowie
e
f
auf
Q
liegt.
umfasst die Kreuzungsmenge
vor dem Kreuzungselement (bezüglich
<Q )
auf zwei Pfaden, die
<P ) und die Elemente
selbst. Es ist nicht erforderlich, dass
(P, e, Q)
selbst
einen Pfad bildet. Es ist aber garantiert, dass zumindest ein Pfad in jeder Kreuzungsmenge
liegt, da der leere Pfad
2
∅ in der Menge der Pfade enthalten ist. Dadurch ist r
wohldeniert.
Wenn alle Kanten umgedreht werden und die Quelle und Senke ihre Rollen tauschen, kann dieser mit
den gleichen Algorithmen berechnet werden.
16
2.4 Das abstrakte Graphmodell
e
e
(a) Die Kreuzungsmenge (P, e, Q).
(b) Kreuzungsmenge (Q, e, P ).
Abbildung 2.1: Zwei Pfade P (horizontal) und Q (diagonal), die sich in einem Element e berühren
sowie deren beide Kreuzungsmengen.
Es ist einfach, ein gegebenes Netzwerk
N = (V, E, s, t, c)
in das abstrakte Modell zu
überführen. Eine Beschreibung des Verfahrens ist im Beweis zu Satz 2.4.6 zu nden.
Es lassen sich auch ohne Probleme Varianten mit mehreren Quelle-Senke-Paaren in diesem Modell darstellen. Ebenfalls sind Formulierungen, die auf Knoten, anstatt auf Kanten,
basieren, möglich. Weitere Beispiele sind in [20] zu nden. Falls den Kanten
klischen Graphen Gewichte
w(e) ∈ N0
zugeordnet sind, kann
r(P ) :=
P
e
eines azy-
w(e)
gesetzt
e∈P
werden und (2.7) wird erfüllt. In einem solchen Modell können Transportprobleme oder
das Problem einen Fluss mit minimalen Kosten zu nden gelöst werden. Ein Algorithmus
dazu, der den in Abschnitt 3.2 vorgestellten Algorithmus verallgemeinert, ist in [26] zu
nden. Im Folgenden werden wir den oben beschriebenen Fall für ungewichtete Graphen
besprechen. Wir denieren dazu einen Fluss auf abstrakten Graphen:
2.4.2 Denition (Abstrakter Netzwerkuss).
Die Funktion
Sei
φ∈
c : E → R≥0
|P|
R≥0 .
φ
Sei
G = (E, P)
weise jedem Element eine nichtnegative
ist ein gültiger
Pfaduss,
ein abstrakter Graph.
Kapazität c(e) zu.
falls er die Kapazitäten einhält, das heiÿt es
gilt
X
∀e ∈ E :
φP ≤ c(e).
P :e∈P
Falls für ein Element
e
X
φP = c(e)
P :e∈P
gilt, ist
e
saturiert.
Ein Pfad
Der
Wert
P
heiÿt
positiv, falls φP > 0 gilt.
eines Flusses
φ
ist deniert als
val(φ) :=
X
φP .
P ∈P
17
2 Grundlagen
Der Fluss
Fluss
φP
φ
ist also ein Vektor der Länge
|P|,
der jedem Pfad
P
einen nichtnegativen
zuweist.
Folgendes lineare Programm beschreibt das Problem, einen maximalen Fluss in der pfadbasierten Variante zu nden:
2.4.3 Algorithmus (Lineares Programm für einen maximalen Fluss).
Eingabe: Ein abstrakter Graph
Ausgabe: Ein maximaler Fluss
G = (E, P)
φ
in
mit Kapazitäten
c(e)
für alle
e ∈ E.
G.
P
(P ) maximiere
φP
P ∈P
P
s.t.
φP
≤ c(e) ∀ e ∈ E
xP
≥ 0
P :e∈P
∀P ∈ P
Das duale Programm berechnet einen Schnitt mit minimalen Wert in einem (abstrakten)
Graphen:
2.4.4 Algorithmus (Duales Programm zum maximalen Fluss).
Eingabe: Ein abstrakter Graph
G = (E, P)
Ausgabe: Ein minimaler Schnitt
y
in
(D) minimiere
mit Kapazitäten
c(e)
für alle
e ∈ E.
G.
P
e∈E
s.t.
c(e)ye
P
ye ≥ 1 ∀ P ∈ P
P ∈P
ye ≥ 0 ∀ e ∈ E
Dies sind die beiden dualen Programme zur Berechnung eines Flusses mit maximalem
und eines Schnittes mit minimalem Wert. Wir überprüfen noch kurz, dass die beiden
Programme tatsächlich duale lineare Programme sind.
2.4.5 Satz. Algorithmus 2.4.4 ist das duale Programm zu Algorithmus 2.4.3.
Beweis.
Sei
m := |E|
T
denieren wir c
∈
Rp
und damit die Matrix
die Anzahl der Kanten und
:= (1, 1, . . . , 1)
(
1
aij :=
0
und für
p := |P|
die Anzahl der Pfade. Dann
i ∈ {1, 2, . . . , m}
Kante
i
liegt auf Pfad
j ∈ {1, 2, . . . , p}
sei
j
sonst
A := (aij ). Dann lässt sich für jede Kante ei
linearen Programm in 2.4.3 darstellen als
ai1 X1 + ai2 X2 + · · · + aip Xp ≤ c(ei ).
18
und
die Bedingung aus dem
2.4 Das abstrakte Graphmodell
Mit
b := (c(e1 ), c(e2 ), . . . , c(em ))T
und
x := (φ1 , φ2 , . . . , φp )T
gilt dann
Ax ≤ b.
Die
yi
bezeichnen die dualen Variablen für jede Ungleichung aus dem primalen linearen
Programm. Mit den Matrixelementen
aij
lässt sich jede Ungleichung des dualen Programms
darstellen als
a1j y1 + a2j y2 + · · · + amj ym ≥ cj
y := (y1 , y2 , . . . , ym )T
und mit
gilt
AT y ≥ c.
Die beiden Programme sind also primales und duales Programm für das Problem einen
maximalen Fluss zu bestimmen.
Die Denition eines abstrakten Graphen ist sehr allgemein, da sie es erlaubt, abstrakte Graphen auf beliebige Mengen zu denieren. Die gleiche Benennung der Kanten von
Graphen in Denition 2.2.1 und der Elemente in Denition 2.4.1 deutet bereits an, welche Interpretation wir im Folgenden annehmen wollen: Wir werden die Elemente eines
abstrakten Graphen als Kanten auassen und die Pfade als Folge von Kanten.
Wie bereits angedeutet, können Netzwerke problemlos in abstrakte Graphen transformiert werden. Ein maximaler Fluss stimmt dann in beiden Modellen überein.
2.4.6 Satz (Transformation eines Netzwerks in einen abstrakten Graphen). Sei
ein Netzwerk N = (V, E, s, t, c) gegeben. Dann gibt es einen abstrakten Graphen G =
(E, P), der dem Netzwerk entspricht. Auÿerdem ist der maximale Flusswert auf dem abstrakten Graphen und N gleich.
Beweis.
Die Menge der Elemente entspricht der Menge der Kanten
Pfad wird ein Pfad in
E
von
N . Für jeden s-t-
P eingefügt. Sei P = (v1 , v2 , . . . , vn ) ein s-t-Pfad in N . Dann ist P 0 :=
{(v1 , v2 ), (v2 , v3 ), . . . , (vn−1 , vn )} deniert als Menge der den Kanten auf P
entsprechenden
Elementen.
Seien
e := (vi , vi+1 )
und
f := (vj , vj+1 )
auf
P.
Wir denieren die Ordnungsrelation
e <P f :⇔ i < j . e ist genau dann kleiner als f , wenn e in N
S
P :=
P 0 die Vereinigung aller solcher Pfade P 0 .
als
P :P
ist ein
Für alle
s-tPfad
P0 ∈ P
sei
r(P 0 ) := 1.
Dann gilt stets für
P0
und
Q0
links von
und
f
<P
liegt. Es sei
e ∈ P 0 ∩ Q0
max{r(R) | R ∈ (P 0 , e, Q0 )} + max{r(S) | S ∈ (Q0 , e, P 0 )} = 1 + 1 = r(P ) + r(Q)
und 2.7 ist erfüllt.
2.4.7 Satz (Homan [20]). Sei G = (E, P) ein abstrakter Graph mit m := |E| Elemen-
ten und p := |P| Pfaden und c = (c1 , c2 , . . . , cp ) ∈ Np0 .
19
2 Grundlagen
Dann haben die beiden dualen Programme
P
(P ) maximiere
r(P )xP
P
xP
P ∈P
s.t.
≤ c(e) ∀ e ∈ E
P :e∈P
xP
und
(D) minimiere
P
e∈E
s.t.
≥ 0
∀P ∈ P
c(e)ye
P
ye ≥ r(P ) ∀ P ∈ P
P ∈P
ye ≥ 0
∀e ∈ E
eine ganzzahlige optimale Lösung.
Beweis.
Ein Beweis ndet sich in [20, Theorem 2.4].
2.4.8 Korollar. Sei N
ein Netzwerk mit ganzzahligen Kapazitäten c(e) ∈
N für alle e ∈ E . Dann gibt es einen maximalen Fluss, der jeder Kante einen ganzzahligen
Fluss zuweist.
Beweis.
= (V, E, s, t, c)
Nach Satz 2.4.6 kann aus
N
ein abstrakter Graph mit gleichem Fluss erzeugt
werden. Nach Satz 2.4.7 ist dieser Fluss ganzzahlig. Somit ist auch der Kantenuss in
N
ganzzahlig.
20
3 Maximale Flüsse
3.1 Flussaugmentierende Verfahren
3.1.1 Das Ford-und-Fulkerson-Prinzip
Aus der Existenz der Pfad-Dekomposition (Satz 2.2.11) folgt, dass es immer einen maximalen Fluss gibt, der nur entlang von
s-t-Pfaden
Fluss führt. Als Verfahren macht es also
Sinn, Fluss nur entlang von passenden Pfaden zu erhöhen und Kreise zu ignorieren. In diesem Fall vereinfacht sich die Berechnung des Flusswertes zu
val(φ) = sout
für einen Fluss
φ. Eine erste Idee zur Umsetzung des Verfahrens ist, ausgehend vom Nulluss, schrittweise
den Fluss entlang eines Pfades zu erhöhen, bis kein weiterer
s-t-Pfad
zum Augmentieren
mehr gefunden wird. Abbildung 3.1 zeigt, dass dieses Verfahren in dieser Form nicht funktioniert, da die Pfade schnell eine Sackgasse bilden können, ohne dass ein maximaler Fluss
gefunden worden ist.
1
s
1
t
s
1
t
s
t
2
2
2
(a) Der Beispielgraph mit Kapazität 1 für jede Kante.
(b) Der maximale Fluss mit
Wert 2.
(c) Der Fluss, falls entlang des
Pfades (s, 1, 2, t) augmentiert wird.
Abbildung 3.1: Der einfache Graph aus (a) zeigt, dass schrittweises Augmentieren nicht immer
einen maximalen Fluss liefert. Der maximale Fluss mit Wert 2 ist in (b) dargestellt.
Falls jedoch im ersten Augmentierungsschritt der Pfad aus Abbildung (c) gewählt
wird, kann der Fluss nicht weiter erhöht werden.
Zur Lösung des Problems muss Fluss
umgeleitet werden, das heiÿt auf Kanten, die bereits
Fluss führen, muss der Fluss wieder verringert werden können. In der Situation aus Abbildung 3.1 (c) genügt es, Fluss entlang des Pfades
Kante
(s, 2, 1, t) zu schicken, wobei entlang der
(1, 2) der Fluss nicht erhöht, sondern verringert wird. Die Flussbedingungen bleiben
21
3 Maximale Flüsse
Residualnetzwerke
dadurch erhalten. Um Fluss tatsächlich umleiten zu können, werden
benutzt, die ein Netzwerk um zusätzliche Kanten erweitern.
3.1.1 Denition (Residualnetzwerk).
schen jedem Knotenpaar
ist und
φ
nur eine der beiden Kanten
(v, w)
oder
(w, v)
enthalten
←
Rückwärtskante zu e = (v, w) ∈ E und E := {←e | e ∈ E} die
Rückwärtskanten. Die Restkapazität von e ∈ E bezüglich φ ist deniert als
e := (w, v)
Menge der
N = (V, E, s, t, c) ein Netzwerk, in dem zwi-
N.
ein Fluss auf
←
v, w ∈ V
Sei
heiÿt
cφ (e) := c(e) − φ(e) und die Restkapazität der zugehörigen Residualkante ←
e ist deniert als
cφ (←
e ) := φ(e). Das Residualnetzwerk
←
zum Fluss
φ ist deniert als Nφ := (V, E ∪ E, s, t, cφ ).
0
2/2
1
2
2/8
1
0/2
t
s
2
0/1
0
5/7
4
t
2
3
3/3
3
1
2
2/2
s
2
2
6
0/1
5
1
0
3
2
5
4
5/8
(a) Ein Netzwerk mit Fluss 5. Die Zahlen an den
Kanten geben an, wieviel Fluss über sie ieÿt.
Der maximale Fluss ist 8. Damit er erreicht werden kann, muss auf (2, 3) Fluss zurückgenommen werden.
3
(b) Das Residualnetzwerk mit den Restkapazitäten.
Gestrichelte schwarze Kanten sind Residualkanten, blaue gestrichelte Kanten sind ausgeschöpft
und können bei der Pfadsuche nicht mehr benutzt werden.
Abbildung 3.2: Ein Netzwerk mit einem Fluss und das zugehörige Residualnetzwerk.
Wir haben in dieser Denition die Einschränkung, dass nur eine Kante zwischen einem
Paar von Knoten im Netzwerk vorhanden ist. Wenn es zwei solcher Kanten gäbe, würde das
Hinzufügen der Residualkanten zu einem Multigraphen führen. Das ist keine Einschränkung, denn wenn zwischen zwei Knoten beide Kanten existieren, kann die Situation durch
Einfügen eines Dummyknotens in eine der beiden Kanten bereinigt werden.
d
v
w
(a) Ein Kreis mit zwei Knoten.
v
w
(b) Die Auösung mit dem temporären Knoten
d. Es gilt c(v, d) := c(d, w) := c(v, w).
Abbildung 3.3: Hinzufügen eines Dummyknotens, falls zwischen einem Knotenpaar beide gerichteten Kanten existieren.
In Residualnetzwerken funktioniert die obige Idee, den Fluss sukzessive entlang augmentierender
22
s-t-Pfade
zu erhöhen. Dabei werden Kanten mit Restkapazität 0 ignoriert.
3.1 Flussaugmentierende Verfahren
3.1.2 Algorithmus (Ford und Fulkerson [9]).
←
Eingabe: Ein Residualnetzwerk
Ausgabe: Ein maximaler Fluss
1
φ := 0
2
do
4
5
6
8
9
φ
und ein Fluss
φ.
N.
auf
if existiert flussvergr ö ÿ ernder s - t - Pfad P in Nφ
δ := min{cφ (e) | e ∈ P }
for e ∈ E ∩ P
φ(e) := φ(e) + δ
3
7
Nφ := (V, E ∪ E, s, t, cφ )
←
for ←
e ∈E∩P
φ(←
e ) := φ(←
e) − δ
while existiert s - t - Pfad P
Allgemein heiÿt das Verfahren, den Fluss in einem Residualnetzwerk schrittweise vom
Nulluss zum maximalen Fluss zu saturieren,
Ford und Fulkerson-Prinzip. Viele Algorith-
men verfolgen dieses Prinzip und unterscheiden sich jeweils darin, wie eine zur Augmentierung genutzte Kantenmenge gefunden wird.
3.1.3 Satz (Korrektheit des Ford und Fulkerson-Algorithmus). Sei ein Netzwerk
gegeben. Dann berechnet Algorithmus 3.1.2 einen maximalen Fluss φ auf
N . Die benötigte Laufzeit ist O(mnU ) mit U := max{c(e) | e ∈ E}.
N = (V, E, s, t, c)
Beweis.
In jeder Iteration der Schleife wird der Fluss um 1 erhöht. Da der Fluss nach oben
beschränkt ist, hat der Algorithmus endliche Laufzeit.
Betrachten wir die Situation, wenn der Algorithmus abbricht. Es gibt dann keinen
Pfad mehr in
Nφ .
Wie in Lemma 2.3.2 sei
erreichbaren Knoten und
Vt := V \ Vt .
Vs := {v ∈ V | ∃s-v -Pfad
Die Menge
in
Nφ }
s-t-
die Menge der
S := {e = (v, w) ∈ E | v ∈ Vs , w ∈ Vt }
bildet einen Schnitt, dessen Wert mindestens so groÿ ist wie der Flusswert.
Alle Kanten
Pfad
e = (v, w) ∈ S
(s, . . . , v, w)
sind saturiert, ansonsten könnte der Knoten
erreicht werden. Kanten
Fluss, da sonst die Residualkante
s
e = (w, v)
←
e = (v, w) in S
mit
w ∈ Vt
und
v ∈ Vs
w
über den
führen keinen
positive Kapazität hätte und
w
auch von
erreicht werden könnte.
Weil (2.6) in Residualnetzwerken weiterhin gilt folgt zusammen mit diesen Betrachtun-
gen
X
val(φ) = val(S) −
φ(e)
e=(v,w):v ∈V
/ s ,w∈Vs
= val(S) − 0
Ein ussvergröÿernder
s-t-Pfad kann in O(m) gefunden werden. Wenn entlang des Pfades
augmentiert wird, wird eine vorher unsaturierte Kante saturiert und der Fluss um minde-
23
3 Maximale Flüsse
stens 1 erhöht. Da der maximal zu erreichende Fluss durch
ist die Gesamtlaufzeit
n·U
nach oben beschränkt ist,
O(mnU ).
3.1.2 Algorithmus von Edmonds und Karp
Wie in Abbildung 3.4 gezeigt, kann der Algorithmus tatsächlich pseudopolynomielle Laufzeit haben, wenn die Pfade entlang denen augmentiert wird, schlecht ausgewählt werden.
Edmonds und Karp [7] und Dinic [6] haben gezeigt, dass es genügt, nur kürzeste augmentierende Wege zu betrachten. Dadurch kann der maximale Fluss in streng polynomieller Zeit
berechnet werden. Im Beispielgraphen genügt es, den Fluss entlang der beiden Wege der
Länge 2 zu augmentieren, um bereits mit zwei Augmentierungsschritten einen maximalen
Fluss zu berechnen.
3.1.4 Algorithmus (Edmonds und Karp).
Eingabe: Ein Residualnetzwerk
Ausgabe: Ein maximaler Fluss
1
φ := 0
2
do
4
5
6
8
9
φ
auf
und ein Fluss
φ.
N.
if existiert k ü rzester flussvergr ö ÿ ernder s - t - Pfad P in Nφ
δ := min{cφ (e) | e ∈ P }
for e ∈ E ∩ P
φ(e) := φ(e) + δ
3
7
←
Nφ := (V, E ∪ E, s, t, cφ )
←
for ←
e ∈E∩P
←
φ( e ) := φ(←
e) − δ
while existiert s - t - Pfad P
3.1.5 Satz (Edmonds und Karp [7]). Der Algorithmus von Endmonds und Karp be-
rechnet in einem Netzwerk N = (V, E, s, t, c) mit n := |V | Knoten und m := |E| Kanten
einen maximalen Fluss in Laufzeit O(m2 n).
Beweis.
Wir beweisen zunächst eine Hilfsaussage. Es seien
Flüsse, wobei
φi
entlang des Pfades
Pi
augmentiert werde und
φ1 , φ2 , . . .
Pi
die entstandenen
ein kürzester augmentie-
render Pfad sei.
Es sei
k < `. Falls die Pfade Pk+1 , Pk+2 , . . . , P`
Rückwärtskante
←
e
nicht eine Kante
enthalten, gilt
|Pk | ≤ |Pk+` |
insbesondere gilt für alle
k
|Pk | ≤ |Pk+1 |.
24
e und gleichzeitig deren
3.1 Flussaugmentierende Verfahren
1
1
M
1
M
s
M
s
t
1
s
t
t
M
2
2
2
(a) Die äuÿeren Kanten haben
Kapazität M 1, die
mittlere Kante Kapazität
1.
(b) Der erste augmentierende
Pfad.
(c) Der zweite augmentierende Pfad, der (1, 2) als
Rückwärtskante benutzt.
Abbildung 3.4: Der maximale Fluss für dieses Netzwerk ist 2M und kann in zwei Augmentierungsschritten entlang der Pfade (s, 1, t) und (s, 2, t) erreicht werden. Bei einer ungünsitgen Wahl der Pfade werden jedoch 2M Schritte benötigt, jeweils abwechselnd M
Schritte wie in (b) und (c).
←
Es sei
P` ,
E 0 := {e ∈ E ∪ E | e ∈ Pk ∪ P` ∧ ←
e∈
/ Pk ∪ P` } die Multimenge aller Kanten in Pk
und
die nicht zusammen mit ihrer Rückwärtskante auf den beiden Pfaden enthalten sind.
Kanten, die auf beiden Pfaden liegen, kommen doppelt in
E0
vor. Es ist dann
G0 := (V, E 0 )
der aus dieser Kantenmenge entstehende Graph.
Für einen Fluss
φi
sei die Menge der benutzten Kanten deniert als
←
Eφi := {e ∈ E ∪ E | φi (e) > 0}.
Dann gilt
nicht in
E 0 ⊆ Eφk :
E φk
Da
φk
enthalten war, aber in
sein, die von einem der Pfade
setzung in
durch
Pk+1 , . . . , Pk+`−1
Pk
augmentiert wird, gilt
Eφk+`
Pk ⊆ Eφk .
Eine Kante, die
enthalten ist, muss Rückwärtskante einer Kante
Pk , Pk+1 . . . , Pk+`−1
hinzugefügt worden ist. Da nach Voraus-
eine solche Kante nicht vorkommt, muss sie in
sein. Diese Kanten werden jedoch nicht in
0
In E existieren zwei kantendisjunkte
E0
Pk
enthalten
aufgenommen.
s-t-Pfade Q1
und Pk+` eine Kante
0
doppelt nutzen, gibt es an dieser Stelle die Mehrfachkanten in E . Wenn die Pfade jedoch
und
Q2 : Falls Pk
eine Vorwärts- und Rückwärtskante gemeinsam benutzen, wird ein solches Kantenpaar
entfernt. Betrachten wir zunächst den Pfad
e1 = (v1 , w1 )
entfernt worden ist. Dann liegt
die Kanten ab
v1
auf
Pk+`
Pk
v1
bis zur ersten Stelle, an der eine Kante
auf
Pk+`
und wir können den Pfad über
verlängern bis zur zweiten Kante
und rückwärts durchlaufen wird. Ab
v2
e2 = (v2 , w2 ),
die vorwärts
kann der Pfad wieder ein Stück entlang von
Pk
verlängert werden. Schlieÿlich wird irgendwann die Senke erreicht. Die alternierenden Teilstücke zusammen bilden so den Pfad
Q1 .
Wenn wir mit dem ersten Teilstückvon
beginnen, können wir genauso verfahren um den Pfad
Q2
Pk+`
zu bilden. Diese Konstruktion
ist in Abbildung 3.5 zu sehen.
25
3 Maximale Flüsse
v
w
v
(a) Der grüne Pfad ist Pk , der blaue Pk+` . Die
Kanten (v, w) und (w, v) werden nicht in E 0
aufgenommen.
w
(b) Die Pfade Q1 und Q2 , die bis v , beziehungsweise ab w, den Pfad Pk nutzen und auf den
Pfad Pk+` wechseln.
Abbildung 3.5: Eine Kante (v, w), die von Pk und als Rückwärtskante auch von Pk+1 benutzt wird.
Es existieren Wege über v und w, die den benutzten Pfad wechseln.
Bei der Konstruktion können keine Probleme auftreten. Jeder Knoten hat entweder vier
oder zwei eingehenden und ausgehenden Kanten, oder gar keine. Die möglichen Fälle wer3
den in Abbildung 3.6 dargestellt.
v
w
v
(a) Ein Knoten wird nur auf
einem Pfad benutzt.
w
v
(b) Die beschriebene Situation, in der die Kanten zwischen v und w entfernt
werden.
w
(c) Die doppelte Kante (v, w)
kann von beiden kantendisjunkten Pfaden benutzt
werden.
Abbildung 3.6: Die möglichen Situationen, die an einem Knoten auftreten können. Falls sowohl
beide eingehenden als auch ausgehenden Kanten entfernt werden, ist der Knoten
isoliert und wird nicht betrachtet.
Pk
Da
ein kürzester augmentierender Pfad war, gilt
|Pk | ≤ |Q1 |
und
|Pk | ≤ |Q2 |
und
damit
|Pk | + |Pk | ≤ |Q1 | + |Q2 | ≤ |E 0 | ≤ |Pk | + |Pk+` | ⇔ |Pk | ≤ |Pk+` |
Falls
Pk ∪ Pk+`
eine Kante und gleichzeitig die zugehörige Rückwärtskante enthalten, gilt
auch
|Pk | + 2 ≤ |P` |.
Hierfür genügt es,
Pi ∪ P`
k
und
`
i ∈ {k + 1, k + 2, . . . , ` − 1}
in
kein Paar einer Kante und zugehörigen Rückwärtskante enthalten ist, denn für alle
sonstigen Pfade kann wegen
3
so zu wählen, dass für alle
|Pk | ≤ |Pk+1 |
die entsprechende Ungleichung gezeigt werden.
Gerichtete Graphen, mit der Eigenschaft, dass | d+ (v)| = | d- (v)| an jedem Knoten v gilt, heiÿen Euler'sch. Ein Euler'sches Netzwerk mit zusätzlichen Kanten (t, s) enthält allgemein so viele disjunkte
Pfade wie Kanten (t, s). Damit folgen die gezeigten Eigenschaften ebenfalls (vgl. [24, Kapitel 8.2 und
8.3]).
26
3.1 Flussaugmentierende Verfahren
Da mindestens zwei Kanten entfernt werden, gilt diesmal für die gefundenen kantendisjunkten Pfade
Q1
und
Q2
|Pk | + |Pk | ≤ |Q1 | + |Q2 | ≤ |E 0 | ≤ |Pk | + |Pk+` | − 2 ⇔ |Pk | + 2 ≤ |Pk+` |.
Jeder Pfad
Pi ,
der augmentiert wird enthält mindestens eine Flaschenhalskante, die
festlegt. Seien für eine solche Flaschenhalskante
den Pfade, auf denen sie liegt. Da
aufeinanderfolgende Pfade
die Rückwärtskante
←
e
Pj
und
liegt, die
e
e
e
die Pfade
ein Pfad
Pk
mit
ij < k < ij+1
wieder unsaturiert. Falls
3
e
nicht
s
j.
existieren, auf dem
t
oder
als Endpunkt
Kanten lang sein und können nicht alle
enthalten, da sonst jeder Knoten benutzt worden wäre. Es gilt also
alle
die augmentieren-
durch jeden dieser Pfade saturiert wird, muss für zwei
Pj+1
hat, müssen die Pfade mindestens
Pi1 , Pi2 , . . .
δ
n
Kanten
3 ≤ |Pij | ≤ n − 1
für
Wegen
|Pij | + 2 + 2 ≤ |Pk | + 2 ≤ |Pij+1 |
Pij für wachsende j jeweils um 4 Kanten länger, insgesamt gibt es also höchstens
1
4 (n − 1) + 1 solcher Pfade die e als Flaschenhalskante enthalten. Falls e an der Quelle oder
werden die
Senke liegt, enthält mindestens einer der Pfade diese Kante als Flaschenhalskante. Da keine
Pfade mehr zur Quelle zurück- oder aus der Senke herausführen, werden sie nicht mehr
benutzt. Sie bleiben damit saturiert.
Jeder Pfad enthält mindestens eine Flaschenhalskante. Insgesamt gibt es
m
Kanten. Es
mn
kann also höchstens
2 augmentierende Pfade geben. Da jede Pfadsuche mittels Breiten2
suche Laufzeit O(m) hat, beträgt die Gesamtlaufzeit des Algorithmus O(m n).
Der fast zeitgleich von Dinic angegebene Algorithmus [6] verändert den Fluss nicht mehr
nur auf Pfaden, sondern auf einer gröÿeren Kantenmenge, dem sogenannten
Sperruss.
Dabei werden gleichzeitig alle kürzesten Pfade augmentiert. Wie im Beweis von Satz 3.1.5
gezeigt, werden kürzeste Pfade immer länger. Gleichzeitig werden alle kürzesten Pfade
gefunden. Es werden also nur
n Augmentierungsphasen mit jeweils Laufzeit n · m durchge-
führt. Die Laufzeit ist somit durch
O(mn2 )
beschränkt. Die Sperrussberechnung wurde
weiter verbessert, so zum Beispiel von Malhotra, Kumar und Maheshwari [25], die einen
Präuss nutzen, der zunächst ungültig ist und verbessert wird. Dadurch kann ein Sperruss
in
O(n2 )
berechnet werden, was zu einer Gesamtlaufzeit von
O(n3 )
führt.
Ein komplett anderer Ansatz wurde 1988 von Goldberg und Tarjan [13] veröentlicht.
Sie benutzen auch einen Präuss, der solange auf einzelnen Kanten geändert wird, bis
ein gültiger Fluss entsteht, der dann auch maximal ist. Für dieses
(oder auch
Preow-Push-Verfahren
Push-Relabel-Verfahren ) gibt es ebenfalls verschiedene Implementierungen und
3
kann
O(n ) und
2
imO nm log nm
(heuristische) Verbesserungen. Die erste Variante hatte eine Laufzeit von
mit einer speziellen Datenstruktur von Sleator und Tarjan [33] in
plementiert werden. Die zur Zeit schnellsten Varianten stammen von King, Rao und Tarjan [23] sowie Goldberg und Rao [12] mit Laufzeiten von
O mn + n2+ε
beziehungsweise
27
3 Maximale Flüsse
2
2
1
O min n 3 , m 2 m log nm log U ,
wobei
U := max{c(e) | e ∈ E}
die maximale Kapa-
zität ist.
Planare Graphen
Ford und Fulkerson gaben 1956 einen Algorithmus an, der einen ma-
ximalen Fluss in einem
st-planaren
Variante in der Ebene gezeichnet (
Graphen berechnet. Dies sind Graphen, die auf eine
eingbettet )
werden können, in der sich keine Kanten
kreuzen. Zusätzlich liegen die Quelle und die Senke auÿen.
In diesem speziellen Fall kann (ausgehend von einer Einbettung) der Pfad immer entlang
der obersten Pfade augmentiert werden. Da in diesem Fall niemals Fluss zurückgenommen
werden muss, kommt die Berechnung ohne Residualkanten aus. Dieser Algorithmus hat ohne weitere Optimierungen eine Laufzeit von
in einem
st-planaren
O(m2 ). Hassin zeigte, dass ein maximaler Fluss
Graphen einem kürzesten
s-t-Weg
im zugehörigen
dualen Graphen 4
entspricht[18]. In planaren Graphen können kürzeste Wege in linearer Zeit in der Anzahl
der Knoten berechnet werden[19]. Zusammen führt dies zu einem
Berechnung maximaler Flüsse in
st-planaren
O(n)-Algorithmus
zur
Graphen.
3.2 Das Abstrakte-Fluss-Verfahren
3.2.1 Vorüberlegungen
Sowohl Homans Beweis [20] von Satz 2.4.7 als auch der originale Beweis zum einfachen
Max-Flow-Min-Cut-Theorem auf Graphen von Ford und Fulkerson [10] sind nicht konstruktiv. McCormick [27] entdeckte einen polynomiellen Algorithmus, der im von Homan
eingführten Szenario der abstrakten Graphen (vgl. Denition 2.4.1) einen maximalen Fluss
berechnet.
Wir betrachten den Algorithmus zunächst in der ursprünglichen Version von McCormick; in Kapitel 4.1 wird das Verfahren des Algorithmus dann auf kantenbasierte Flüsse in
Netzwerken nach Denition 2.2.4 angewendet. Sei im Folgenden
Graph mit
m := |E|
Elementen und einem Fluss
φ.
Die Menge
G = (E, P) ein abstrakter
P+ := {P ∈ P | φP > 0}
bezeichnet die Menge der positiven Pfade. Zusätzlich zu den Voraussetzungen in Denition
2.4.1 fordern wir, dass in jeder Kreuzungsmenge
(P, e, Q)
ein Pfad
Zur Berechnung eines maximalen Flusses werden die Pfadgewichte
R 6= ∅
r(P )
enthalten ist.
nicht benötigt.
Das Problem bei pfadbasierten Darstellungen von Flüssen ist die groÿe Anzahl der möglichen Pfade, die im schlechtesten Fall exponentiell in
m
ist. Das Problem kann umgangen
werden, indem die Pfade nicht gespeichert werden, sondern ein Orakel angenommen wird,
das einen Pfad angeben kann. Zusätzlich werden alle Pfade
φP > 0
4
P
mit echt positivem Flusswert
gespeichert.
Eine Einbettung eines Graphen unterteilt die Ebene in Flächen. Im dualen Graphen entspricht jeder
dieser Flächen einem Knoten. Zwei Knoten sind verbunden, wenn ihre Flächen im ursprungsgraphen
aneinander grenzen.
28
3.2 Das Abstrakte-Fluss-Verfahren
3.2.1 Bemerkung.
Sei
Kn ein vollständiger gerichteter Graph mit n Knoten, dessen Kan-
ten von Knoten mit niedrigem Index zu Knoten mit hohem Index verlaufen (vgl. Denition
4.3.1). In solchen Graphen gibt es für
n.
n≥2
K2
Ein Beweis folgt per Induktion. Ein
genau
2n−2
Pfade zwischen den Knoten
es also einen
Pfad über
i ∈ {1, 2, . . . , n}
1-(n + 1)-Pfad
(1, n + 1).
die Kanten
(i, n + 1)
der die neue Kante
Sei die Anzahl der
IV
=
n
X
i=2
n
X
Kn
zu einem
hinzugfügt. Für jeden
(i, n + 1)
1-i-Pfade
P (1, n + 1) =
und
besteht aus zwei Knoten die mit einer Kante
verbunden sind und es gibt genau einen Pfad. Erweitern wir nun einen
Es werden für
1
mit
Kn+1 .
1-i-Pfad
gibt
nutzt. Zusätzlich gibt es einen
P (1, i)
bezeichnet. Dann gilt
P (1, i) + 1
2i−2 + 1
i=2
= 2n−2 − 1 + 1 = 2n−2
1
2
3
1
(a) Der K3 enthält die beiden Pfade (1, 3) und
(1, 2, 3); zusätzlich gibt es einen Pfad (1, 2) von
1 nach 2.
2
3
4
(b) Im K4 entstehen aus den Pfaden von 1 nach 3
im K3 die Pfade (1, 3, 4) und (1, 2, 3, 4), der Pfad
(1, 2) kann verlängert werden zu (1, 2, 4) und es
gibt die zusätzliche Kante (1, 4).
Abbildung 3.7: Der induktive Schritt vom gerichteten K3 zum gerichteten K4 . Im ersten Graphen
gibt es zwei 1-3-Pfade, während es durch Verlängerung der Pfade insgesamt 2 + 1 +
1 = 4 = 22 Pfade von 1 nach 4 im K4 gibt.
Die Anzahl der erzeugten positiven Pfade bleibt polynomiell in
m, so dass wir alle Pfade
+ durchsuchen können, wenn es nötig ist. Einen Pfad zu nden, der nicht in
von P
P+
liegt, dauert zu lange. Um trotzdem solche Pfade nden zu können, nutzen wir ein Orakel,
das aus den exponentiell vielen möglichen Pfaden einen passenden aussucht, falls es einen
solchen gibt.
3.2.2 Denition (Orakel).
Das Orakel
O
F ⊆E
eine Teilmenge der Elemente.
ist ein Algorithmus, der einen Pfad
solcher Pfad existiert, stellt
Orakels sei
Sei
O
∅ 6= P ∈ P ∩ F
bestimmt. Falls kein
fest, dass es keinen solchen Pfad gibt. Die Laufzeit des
O(1).
Das lineare Programm 2.4.3 berechnet einen maximalen Fluss, das dazugehörige duale
Programm berechnet einen minimalen Schnitt. Die Probleme einen maximalen Fluss und
29
3 Maximale Flüsse
einen minimalen Schnitt zu nden, sind also dual zueinander. Der Satz des komplementären
Schlupfes (2.1.3) erlaubt nun, Aussagen über die Maximalität von zulässigen Lösungen für
diese beiden Probleme zu treen: sind zwei Lösungen
φ ∈ R|P|
für einen Fluss und
y ∈ Rm
für einen Schnitt gegeben, kann damit getestet werden, ob sie maximal sind.
Der Satz von Homan (2.4.7) impliziert, dass eine ganzzahlige Lösung für Programm
2.4.4 existiert. Die Bedingung des Programms ist für einen Pfad
für ein Element
ein
e∈P
0-1-Vektor. ye
e ∈ L :⇔ ye = 1
Sei
P ∈P
erfüllt. Weil die Summe über positive
P
c(e)ye
bereits mit
ye = 1
minimiert wird, ist
y
kann als Inzidenzvektor aufgefasst werden und bestimmt direkt durch
eine Menge
L ⊆ E.
ein Pfad und es sei
1 − y T AP · φ P = 0
wie in Satz 2.1.3 gefordert. Diese Gleichung ist erfüllt, falls auf dem Pfad kein Fluss ieÿt.
Andernfalls gilt
gleichzeitig
y T AP = a1P y1 + a2P y2 + · · · + amP ym = 1
aiP 6= 0
Umgkehrt sei
und
e∈E
und es ist genau für ein
i
yi 6= 0.
ein Element und es gelte entsprechend
ye · ATe x − c(e) = 0.
Auch diese Gleichung ist trivialerweise für
0 ⇔ Ae1 x1 + Ae2 x2 + · · · + Aep xp = c(e),
ye = 0
erfüllt. Andernfalls gilt
Ae x − c(e) =
die Kapazität des Elements wird also auf dem
Pfad durch den Fluss genau ausgeschöpft.
Für einen gegebenen Fluss
φ
und eine Menge
L ⊆ E
können wir damit überprüfen,
ob es sich um einen maximalen Fluss beziehungsweise minimalen Schnitt handelt. Dies
ist genau dann der Fall, wenn die obigen Betrachtungen gelten und
L
mit dem Vektor
ye
korrespondiert und zusätzlich die beiden trivialen Fälle nicht gelten, das heiÿt es existiert
kein Pfad ohne Fluss.
3.2.3 Eigenschaft (Komplementärer Schlupf).
Sei
L⊆E
und
φ
ein Fluss auf
G.
Jeder positive Pfad enthält genau eine Kante aus
Jedes Element in
L
wird von
φ
L.
saturiert.
(3.1)
(3.2)
Solange diese Eigenschaft nicht gilt, kann der Fluss nicht maximal sein; wir können in
diesem Fall versuchen, einen augmentierenden Pfad zu nden und die Menge
L anzupassen,
so dass die Eigenschaft anschlieÿend gilt. Sie beschränkt sich auf positive Pfade, da es davon
nur polynomiell viele gibt, die wir alle überprüfen können. Falls es noch einen Pfad mit
Fluss 0 gibt, kann der Flusswert erhöht werden und anschlieÿend muss die Eigenschaft für
30
3.2 Das Abstrakte-Fluss-Verfahren
diesen Pfad ebenfalls überprüft werden. Solche Pfade können mit dem Orakel bestimmt
werden. Zunächst wollen wir überlegen, welche Menge
L für unsere Zwecke benutzt werden
kann.
In Lemma 2.3.4 werden die Mengen
S ∗ := {e ∈ E | e
wird saturiert von jedem maximalen Fluss}
und
L∗ := {e ∈ S ∗ | ∃
deniert
auch
S∗
5
Pfad
und es wird gezeigt, dass
trennend.
L∗
P : e ∈ P ∧ ∀ e 6= f ∈ P : f ∈
/ S ∗ ∨ f >P e}
L∗
eine trennende Menge ist; wegen
L∗ ⊆ S ∗
beschreibt die Teilmenge der linkesten Elemente aus
positiven Pfad. Nach dieser Idee bestimmen wir auch die Menge
saturierten Elemente auf jedem positiven Pfad in
φ.
Lφ
S∗
ist dann
auf jedem
als Menge der linkesten
Insgesamt nutzen wir eine Partition
der saturierten Kanten in drei Teilmengen:
Sφ := {e ∈ E | e
wird von
Lφ := {e ∈ Sφ | e
φ
saturiert}
ist linkestes Element auf einem positiven Pfad}
Aφ := Sφ \ Lφ
Tφ := ∅
Lφ
erfüllt automatisch (3.2). Angenommen,
Lφ
erfüllt sogar beide Bedingungen des
komplementären Schlupfes. Wenn gleichzeitig kein Pfad mit Fluss
keine Elemente aus
Lφ
0
mehr existiert, der
benutzt, ist der Fluss optimal. Insgesamt führt dies zu folgendem
Verfahren:
1. Überprüfe, ob die Eigenschaft 3.2.3 erfüllt ist.
2. Wenn das nicht der Fall ist, korrigiere
3. Falls
E \ Lφ
Lφ .
keinen Pfad mehr enthält, ist
φ
ein maximaler Fluss und
Lφ
minimaler
Schnitt.
4. Wenn
φ
nicht maximal war, nde eine Möglichkeit zum Augmentieren und fahre bei
1) fort.
Wir weisen den drei disjunkten Teilmengen von
Sφ
folgende Bedeutung zu:
jeweilige Menge, die vielleicht einen minimalen Schnitt darstellt. Die Menge
Kanten, die eventuell noch zu
bekannt ist.
Lφ
Lφ
Aφ
ist die
enthält
hinzugefügt werden müssen, über die aber noch nichts
kann Elemente enthalten, die zwar saturiert sind, jedoch nicht zwangsweise
saturiert werden müssen, denn nur
L∗
enthält die Elemente, die von jedem Fluss saturiert
werden. Diese fälschlicherweise saturierten Elemente werden in
5
Lφ
Tφ
gesammelt; es können
Die Denition wurde angepasst an die Notation von abstrakten Graphen.
31
3 Maximale Flüsse
also Elemente von
Lφ
nach
Tφ
verschoben werden und von
Aφ
nach
Lφ
oder auch
Tφ .
Die
Anpassung der Mengen soll dabei möglichst gut sicherstellen, dass die Bedingungen des
komplementären Schlupfes gelten.
Da Elemente aus
Tφ
nicht zu jedem maximalen Fluss gehören, erlauben wir solche Ele-
mente auf ussvergröÿernden Pfaden. Da sie jedoch vom aktuellen Fluss bereits saturiert
werden, muss ein anderer Weg gefunden werden, um tatsächlich den Fluss zu erhöhen.
In diesem Fall läuft das so ab, dass wir eine Menge von Pfaden suchen, deren Flusswerte
abwechselnd erhöht und verringert werden können. Damit
val(φ)
tatsächlich erhöht wird,
muss es einen Pfad mehr geben, auf dem der Fluss erhöht wird. Die Initialisierung der
Menge
Lφ
muss dabei in jedem Augmentierungsschritt neu durchgeführt werden.
3.2.2 Pfade nden
Lφ am Anfang jedes Augmentierungsschrittes, genügt es über
+
alle Pfade in P zu iterieren und das jeweils erste saturierte Element festzustellen. Es gilt
Zum Initialisieren der Menge
dann folgende Eigenschaft:
3.2.4 Eigenschaft.
∀ e ∈ Lφ
gilt:
e
ist linkestes Element aus
(Lφ ∪ Aφ )
auf einem Pfad.
Wir wollen diese Eigenschaft für den restlichen Augmentierungsschritt invariant halten.
Darum müssen wir immer, wenn die Menge
Lφ
geändert wird, dafür sorgen, dass die
Invariante weiterhin gilt.
Die Eigenschaften des komplementären Schlupfes gelten jedoch nicht unbedingt. Da nur
saturierte Elemente betrachtet werden, ist (3.2) auf jeden Fall erfüllt. Es können jedoch
Pfade existieren, auf denen mehrere Elemente aus
Lφ
liegen.
Um (3.1) besser zu erfüllen, werden überüssige Elemente in
Tφ
verschoben. Diese Ele-
mente betrachten wir als wären sie nicht saturiert, das heiÿt, dass zusätzlicher Fluss über
sie ieÿen kann. Dies wird in Eigenschaft 3.2.4 angedeutet, wo nur gefordert wird, dass
ein Element aus
Lφ
nur linkestes Element aus
Lφ ∪ Aφ
entlang eines positiven Pfades sein
muss, nicht jedoch linkestes saturiertes Element überhaupt.
Wenn wir überüssige Kanten aus
Lφ
entfernen, nähern wir uns (3.1) zumindest an, da
damit immerhin jeder positive Pfad höchstens ein Element aus
dies, indem Elemente aus
nach
Tφ
L φ ∪ Aφ ,
Lφ
enthält. Realisiert wird
die sich links eines anderen Elements aus
Lφ
benden,
verschoben werden. Dass dies korrekt ist, zeigt folgendes Lemma:
3.2.5 Lemma. Sei φ ein Fluss auf einem Netzwerk G = (E, P) und P ein positiver Pfad
mit einem saturierten Element e ∈ Lφ und einem weiteren saturierten Element f ∈ Lφ ∪Aφ ,
das links von e liegt. Weiterhin existiere ein Pfad P 0 , auf dem e erstes Element aus Lφ ∪Aφ
ist.
Dann existiert ein Fluss φ0 mit gleichem Wert, der f nicht saturiert und f kann dann
in die Menge Tφ verschoben werden.
32
3.2 Das Abstrakte-Fluss-Verfahren
Beweis.
Wir beweisen durch Induktion die stärkere Aussage, dass der Fluss auf dem i-ten
Element
f,
auf das dieses Lemma angewendet wird, um
i-ten
dass jedes nicht saturierte Element im
von
1
2i−1
Sei
Schritt noch mindestens eine Restkapazität
hat.
i = 1,
es werde also das erste Paar saturierter Elemente auf einem positiven Pfad
betrachtet. Nach Voraussetzung ist
ist
1
verringert werden kann und
2i
Tφ = ∅.
e
das erste Element aus
Also kann entlang dieses Pfades mindestens Fluss
Aφ ∪ L φ
1=
auf
P 0,
auÿerdem
1
bis zum Element
20
e
geschickt werden.
Da
von
P
1=
ein positiver Pfad ist, kann der Fluss entlang des Pfades auch mindestens in Höhe
1
verringert werden.
20
Die beiden Pfade schneiden sich in
in
(P 0 , e, P )
Entlang
P
e
und mit dem Orakel können wir einen Pfad
bestimmen und entlang dieses Pfades den Fluss um
kann der Fluss um
ε
alle diese liegen jedoch links von
P 0,
1
2
1
erhöhen.
21
=
verringert werden und er bleibt gültig.
Tatsächlich wird der Fluss nur auf Elementen in
liegt und nicht auf
ε :=
P 00
e
und damit auf
wird der Fluss auf
f
P 00 erhöht, die nicht bereits auf P
P0
und sind nicht saturiert. Da
auf jeden Fall um
ε
f
liegen,
auf
P
verringert. Der Flusswert
ändert sich jedoch nicht. Die freie Kapazität aller (vorher) freien Kanten und auch aller
Kanten in
Sei nun
Tφ
ist nun mindestens
i > 1.
1
1
, jedes positive Element führt mindestens Fluss .
2
21
Nach Voraussetzung ist
e
das erste Element aus
Pfad, auÿerdem kann dieser Pfad auch Elemente aus
Tφ
Das Orakel liefert einen Pfad
erhöht werden kann. Entlang
Da
f
auf
P
und nicht
P0
P
P 00
P
1
verringert werden.
2i−1
1
1
entlang dem der Fluss um ε := · i−1
2 2
wird der Pfad um
liegt, ist
f
1
. Weiterhin kann nach
2i−1
um mindestens
(P 0 , e, P )
in
auf einem
enthalten. Nach Induktionsvor-
aussetzung ist die freie Kapazität dieser Elemente mindestens
Induktionsvoraussetzung der Fluss auf
Aφ ∪ Lφ
=
ε verringert; dabei bleibt der Fluss gültig.
nicht mehr saturiert und kann nach
Tφ
verschoben
werden. Die Kapazität aller (vorher) nicht saturierten Elemente und aller Elemente in
ist nun mindestens
1
2i
1
1
, jedes positive Element führt mindestens Fluss i .
2i
2
T
ein maximaler Fluss ist, können die Elemente, die in Tφ verschoben werden,
∗
nicht in L enthalten sein, da sie von einem Fluss gleichen Wertes nicht saturiert werden.
Falls
φ
Da der neu berechnete Fluss nicht ganzzahlig ist, liefert dieses Lemma kein konstruktives
Vorgehen, das wir benutzen können.
s
v
x
w
t
y
Abbildung 3.8: Die in Lemma 3.2.5 beschriebene Situation. Geschlängelte Kanten entsprechen beliebigen Pfaden im Netzwerk.
33
3 Maximale Flüsse
Es bleibt die Aufgabe, doppelte Kanten in
Lφ ∪ Aφ
entlang positiver Pfade zu nden.
Dazu genügt es, alle positiven Pfade durchzugehen und zu überprüfen, ob mehrere saturierte Elemente aus
Elemente in
Tφ
Lφ
und
Aφ
auf diesem Pfad enthalten sind und die links liegenden
zu verschieben.
3.2.6 Algorithmus (ReduceL).
Eingabe: Die Menge
P+
der positiven Pfade und die Partition
Ausgabe: Eine angepasste Partition
Lφ ∪· Aφ ∪· Tφ
Lφ ∪· Aφ ∪· Tφ .
nach Lemma 3.2.5.
for P ∈ P+ mit |P ∩ Lφ | ≤ 2
e := das rechteste saturierte Element aus Lφ auf P
for f ∈ Lφ ∪ Aφ links von e auf P
Lφ := Lφ \ {f }
Aφ := Aφ \ {f }
Tφ := Tφ ∪ {f }
in(f ) := e
P out (f ) := P
end for
1
2
3
4
5
6
7
8
9
Nachdem dieser Algorithmus ausgeführt worden ist gilt Eigenschaft (3.1). Er arbeitet
korrekt, da nach Lemma 3.2.5 die links liegenden saturierten Elemente nach
Tφ
verschoben
werden können. Das Lemma ist wegen Eigenschaft 3.2.4 anwendbar, da sie zusichert dass
jedes Element in
Lφ
linkestes saturiertes Element auf einem Pfad ist.
3.2.7 Denition (Verletzender Pfad).
φ
und
Sφ = Lφ ∪· Aφ ∪· Tφ
Ein Pfad
P ∈ P,
Sei
G = (E, P) ein abstrakter Graph mit Fluss
die Partition der saturierten Kanten.
der keine Kante aus
Lφ
enthält, heiÿt
Ein verletzender Pfad ist ein Pfad, der beweist, dass
Lφ
verletzender Pfad.
kein Schnitt ist. Mittels des Ora-
kels kann ein solcher Pfad gefunden werden, indem ein Pfad in
E \ Lφ
gesucht wird. Wenn
vor der Orakelanfrage ReduceL ausgeführt worden ist und ein solcher Pfad nicht gefunden wird, ist der Fluss
φ maximal, da nun beide Teile der Eigenschaft des komplementären
Schlupfes gelten.
Andernfalls wurde ein verletzender Pfad
V
gefunden. Falls ein Pfad ohne
Aφ -Elemente
gefunden wurde, können dessen Elemente alle zur Augmentierung benutzt werden. Sonst
sei
f
die linkeste aller
Aφ -Kanten
auf
eine Schnittkante ist, oder ob sie zu
liegt, verschieben wir sie in
Lφ ,
V.
Tφ
Über diese Kante wissen wir noch nicht, ob sie
gehört. Da sie aber auf einem verletzenden Pfad
um damit den komplementären Schlupf besser zu erfüllen.
Allerdings kann es auch passieren, dass es nun wieder einen positiven Pfad gibt, der mehr
als ein Element aus
34
Lφ ∪ Aφ
enthält. Wir fahren also in einer Schleife solange erneut mit
3.2 Das Abstrakte-Fluss-Verfahren
einem Aufruf von Algorithmus 3.2.6 fort, bis entweder ein Pfad ohne
wurde oder
Aφ -Elemente gefunden
φ als maximal erkannt wird. Durch den erneuten Aufruf von Algorithmus 3.2.6
wird Eigenschaft 3.2.4 wieder gesichert. Dies führt zu folgendem Algorithmus:
3.2.8 Algorithmus (SearchForPaths).
Eingabe: Abstrakter Graph mit Fluss
Ausgabe: Ein Pfad
V
ohne
φ
und den Mengen
Aφ -Elemente
do
2
ReduceL()
V := O(E \ Lφ )
e := das linkeste Aφ - Element auf V
if e 6= ⊥
Lφ := Lφ ∪ {e}
Aφ := Aφ \ {e}
until V = ∅ or e = ⊥
3
5
6
7
8
und
oder die Feststellung, dass
1
4
Lφ , Aφ
φ
Tφ .
maximal ist.
3.2.3 Pfad zusammensetzen
Die Pfadsuche stoppt, wenn ein Pfad ohne
Aφ -Elemente
gefunden wurde, der jedoch
Tφ -
Elemente enthalten kann. Lemma 3.2.5 garantiert, dass diese Elemente unsaturiert werden
können, liefert dabei aber einen fraktionalen Fluss. Bei direkter Anwendung des Lemmas
nacheinander auf jede in
Tφ
verschobene Kante könnte der Fluss zwar direkt ganzzahlig
umgeleitet werden, durch weitere Pfadsuchen könnte er jedoch erneut in die Ursprungssituation gebracht werden, so dass eine Endlosschleife entstünde. Stattdessen werden die
saturierten Elemente alle gespeichert und wir können eine Folge von Pfaden berechnen, die
zwischen
den saturierten Elementen den Fluss erhöht oder verringert.
Wir wollen Pfade
c(Pk0 ) für alle
P10 , P20 , . . . , Pj0
nden, die augmentiert werden können, das heiÿt
φPk0 <
1 ≤ k ≤ j.
ReduceL speichert für die in Tφ verschobenen Elemente f den
out
ursächlichen Pfad als P
(f ) und die rechts liegende verursachende Lφ -Kante als in(f ).
Wir werden eine Folge von
out
mente kürzer Pk
in
und schreiben Pk
:=
Tφ -Elementen (ek )
bestimmen und schreiben für solche Ele-
P out (e
k ). Genauso bestimmen wir eine Folge von Lφ -Elementen (ik )
:= P in (ik ). Während entlang der Pfade Pk0 der Fluss erhöht werden soll,
out für 1 ≤ k < j verringert. Wenn der Fluss jeweils um
wird der Fluss entlang der Pfade Pk
δ
erhöht oder verringert wird, ändert sich der Flusswert und
ganzzahligen Fall gilt
jδ − (j − 1) · δ = δ > 0.
δ ≥ 1.
Daher müssen wir die nötigen Pfade noch nden. Falls der zuletzt gefundene Pfad
keine
Tφ -Elemente
Im
enthält, kann der Fluss entlang
V
V
augmentiert werden. Anderenfalls
35
3 Maximale Flüsse
P1in
e1
P1out
i1
P1out
P1
(a) Die Pfade P1 (rot) und P1out (blau) schneiden sich (b) Die Pfade P1in (rot) und P1out (blau) schneiden
in e1 . Der vom Orakel in (P1out , e1 , P1 ) gefundene
sich in i1 . Der vom Orakel in (P1in , i1 , P1out )
Pfad ist dicker gezeichnet.
gefundene Pfad ist dicker gezeichnet.
P1in
e1
i1
P1out
P10
P1
P2
(c) Die dickeren Pfade wurden beide vom Orakel gefunden. Falls P2 keine Tφ -Kante enthält, kann gestoppt
werden. Der Fluss ändert sich nur auf dem Stück zwischen e1 und i1 , auf dem garantiert keine saturierte
Kante liegt. Der Fluss kann entlang P10 und P2 erhöht und entlang P1out verringert werden.
Abbildung 3.9: Die augmentierenden Pfade nach dem ersten Schritt.
sei
P1 = V , e 1
das rechteste
Tφ -Element
auf
P1
und
i1 := in(e1 )
das
Lφ -Element
e1 in Tφ verschoben worden ist.
out
Beide Elemente liegen auf P1 . Nach Eigenschaft 3.2.4 existiert ein Pfad
das in
Algorithmus 3.2.6 dafür sorgte, dass
P1in
auf dem
i1 liegenden saturierten Elemente in Tφ sind. Nach Voraussetzung gibt es in
out
(P1 , e1 , P1 ) einen Pfad P10 6= ∅, der durch einen Orakelaufruf O((P1out , e1 , P1 )) gefunden
out und P in , so dass das Orakel auch einen
werden kann. Gleichzeitig liegt i1 auch auf P1
1
in
out
Pfad P2 in (P1 , ii , P1 ) ndet. Die Situation ist in Abbildung 3.9 beschrieben.
alle links von
Falls sich die bestimmten Pfade nicht überschneiden und
P2
kein
Tφ -Element
links von
i1 enthält, kann der Fluss augmentiert werden: Der Fluss auf den Pfaden P10 und P2 wird
out (i ) verringert. Was passiert, falls sich die berechneten Pfade schneiden,
erhöht und auf P
1
betrachten wir später. Wir betrachten zunächst den Fall, dass
i1
enthält. Dieses Element sei
neue Pfade
P20
in
Falls nun
P3
kein
(P2out , e2 , P2 )
e2
und wie oben sei
P3
und
in
kann das Verfahren mit
e3
i2 := in(e1 ).
(P2in , i2 , P2out )
Tφ -Element links von i2
P2
ein
Tφ -Element links von
Mit dem Orakel können
gefunden werden.
enthält, kann augmentiert werden. Andernfalls
iterativ fortgesetzt werden. Es stoppt, sobald für ein
durch das Orakel gefundene Pfad
Pk
keine
Tφ -Elemente
links von
ik−1
mehr enthält.
3.2.9 Algorithmus (FindPath).
Eingabe: Ein verletzender Pfad
V
Ausgabe: Eine Folge von Pfaden
36
ohne
Pk0 ,
k∈N
Aφ -Elemente
die augmentiert werden können.
der
3.2 Das Abstrakte-Fluss-Verfahren
2
P1 := V
k := 1
3
P0out := ∅
4
out
while Pk \ Pk−1
enth ä lt ein Tφ - Element
out
ek := das rechteste Tφ - Element auf Pk \ Pk−1
ik := in(ek )
Pk0 := Pfad in (Pkout , ek , Pk )
Pk+1 := Pfad in (Pkin , ik , Pkout )
k := k + 1
end while
j := k
Pj0 := Pj
1
5
6
7
8
9
10
11
12
3.2.10 Satz. Der Algorithmus berechnet eine Folge von Pfaden auf denen der Fluss abwechselnd verringert und erhöht werden kann.
Beweis.
Solange die Schleife nicht verlassen wird, ist
out
Pi \Pk−1
ein Pfad, der ein
Tφ -Element
enthält.
Für
1<k<j
links von
out .
Pk−1
ek
auf
sind die Teilpfade
Pk0
liegen auf
out
Pk0 \ P out (ik ) \ Pk−1
P out (ik ).
Sämtliche Elemente links von
Auf
ik−1
Pk
auf
Pk
nicht saturiert, denn alle Elemente
liegen alle Elemente rechts von
liegen auf
in .
Pk−1
in
das linkeste Tφ -Element auf Pk−1 und auf dem Pfad liegen keine
ik−1 .
Der Teilpfad zwischen
ek
und
ik−1
ik−1
auf
Nach Denition ist
Aφ
und
Lφ -Elemente
ek
vor
ist also unsaturiert.
P1in
e1
i1
P10
P2in
P1
e2
P20
P1out
i2
P2out
P30
Abbildung 3.10: Die Menge der Pfade, entlang denen der Fluss in zwei Schritten verändert wird.
Entlang der grünen Pfade wird er erhöht, entlang der roten verringert. Elemente
die auf beiden Pfadtypen liegen, ändern ihren Flusswert nicht.
37
3 Maximale Flüsse
Da die
Pkout
positive Pfade sind, kann Fluss zwischen den Elementen
Pfaden verringert werden. Falls die Pfade bis auf die Elemente
wird der Flusswert erhöht, indem für ein geeignetes
ε
ek
ek
und
und ik auf diesen
ik
disjunkt sind,
der Fluss auf den Pfaden
Pk0
erhöht
out verringert wird. Auf den anderen Teilstücken der Pfade bleibt
und auf den Pfaden Pk
der Fluss gleich. Denn:
Sei
1 < k < j.
Es ist
Pk0 ∩ Pkout ⊆ Pkout
und
out
Pk0 ⊆ Pk−1
und die Start- und Endteile der
Pfade stimmen überein. Darum ändert sich der summierte Flusswert auf den entsprechenden Elementen nicht.
t : E → N0
Zum Abschätzen der Laufzeit nutzen wir eine Hilfsfunktion
und eine Variable
t die zunächst 0 ist. Für jeden positiven Pfad, der in ReduceL betrachtet wird, setzen wir
in Tφ verschoben wird, wird t(f ) := t gesetzt. Wenn auf
in
dem Pfad P (f ) ein saturiertes Element g liegt, muss dieses schon vorher nach Tφ ver-
t um 1 herauf. Wenn eine Kante f
schoben worden sein und daher gilt
Pkin
liegt, gilt
t(ek+1 ) < t(ek ).
t(g) < t(f ). Da für ein ik
Wegen
|T | ≤ |E|
Mit dieser Konstruktion entsteht ein
ek
und ik und zwischen
ek+1
das nächste Element
gibt es maximal
augmentierender Pfad
m
ek+1
auf
Schleifendurchläufe.
aus den Teilpfaden zwischen
und ik , auf denen der Fluss abwechselnd erhöht und verringert
wird.
Ein Element, das auf einem Pfad
out zwischen
Pfad P`
e`
und
des Elements aber bloÿ
i`
Pkout
zwischen
ek
und
liegt, wird um mindestens
2ε
ik
und gleichzeitig auf einem
erhöht. Falls die Restkapazität
ε beträgt, wird sie damit überschritten und es entsteht kein gültiger
Fluss mehr.
Diese Überschneidungen können ebenfalls durch ein Orakelaufruf behoben werden. Wenn
sich zwei Pfade
(Pk0 , e, P`0 )
Pk0
und
zurück, der
P`0
e
in einem Element
e
schneiden, liefert das Orakel einen Pfad in
nur einmal enthält. Auf diese Weise können nacheinander alle
Elemente, die auf mehreren positiven Abschnitten vorkommen, entfernt werden.
3.2.11 Algorithmus (Uncross).
Eingabe: Folge von Pfaden
Pk0
und
Pkout ,
auf denen der Fluss erhöht und verringert
werden kann.
Ausgabe: Eine disjunkte Teilmenge der Folgen.
1
2
3
4
5
6
7
8
38
while Teilpfade zwischen ek und ik nicht disjunkt
Pk0 und P`0 enthalten beide Element e f ü r l < k .
P := O(Pk0 , e, P`0 )
for ` ≤ i < k
l ö sche Pi0
l ö sche P out (ik )
ersetze Pk0 durch P
if i − ` + k ≤ j
3.2 Das Abstrakte-Fluss-Verfahren
0
0
setze Pi0 := Pi−`+k
und l ö sche Pi−`+k
if i − ` + k < j
out
out
setze Piout := Pi−`+k
und l ö sche Pi−`+k
for i = k to j
0
0
Pi0 := Pi−`+k
und l ö sche Pi−`+k
for i = k to j -1
out
Piout := Pi−`+k und l ö sche Pi−`+k
j := k − `
9
10
11
12
13
14
15
16
3.2.4 Der Algorithmus
Wir haben nun alle Bestandteile für die Berechnung eines maximalen Flusses im abstrakten
Graphen beisammen. Der komplette Algorithmus ist wie folgt:
3.2.12 Algorithmus (AbstractMaximumFlow).
Eingabe: Ein abstrakter Graph
G = (E, P)
Ausgabe: Der Wert eines maximalen Flusses
1
φ
sowie ein minimaler Schnitt
Lφ
do
2
Lφ := Aφ := Tφ
3
for P ∈ P+
e := linkestes saturiertes Element auf P
Lφ := e
end for
V = SearchForPaths()
if V = ⊥
break
FindPath()
Uncross()
P
ε := min(minPkout {xP }, min{c(e) −
xP | e ∈ Pk0 , e > ek , e < ik−1 , 1 < k < j})
4
5
6
7
8
9
10
11
12
P :e∈P
13
14
15
16
17
18
19
20
21
22
for k := 1 to j − 1
xPkout := xPkout − ε
xPk0 := xPk0 + ε
end for
xPj0 := xPj0 + ε
while true
φ := 0
for P ∈ P+
φ := φ + xP
end for
39
3 Maximale Flüsse
3.2.13 Satz. Algorithmus 3.2.12 berechnet einen maximalen Fluss in Laufzeit O(|E|4 U 2 ),
dabei ist U := max{c(e) | e ∈ E}.
Beweis.
In jedem Augmentierungsschritt wird der Fluss mindestens um
ximale Fluss ist
|E| · U ,
1
erhöht, der ma-
also gibt es höchstens so viele Augmentierungsschritte. In jedem
Augmentierungsschritt werden alle positiven Pfade mehrmals betrachtet.
Da in jedem Schritt maximal
|E| neue positive Pfade hinzugefügt werden, ist die Anzahl
der positiven Pfade beschränkt durch
|E|2 U .
Im ungünstigsten Fall muss
|E|-mal
nach
einem verletzenden Pfad gesucht werden. Insgesamt ist die Laufzeit für einen Augmentierungsschritt beschränkt durch
|E|3 U .
Damit ergibt sich eine Gesamtlaufzeit von
|E|4 U 2 .
Der Algorithmus hat also pseudopolynomielle Laufzeit. Mit einem Skalierungsschema
kann jedoch eine polynomielle Laufzeit erreicht werden [27]. Ein ähnliches Skalierungsschema haben Edmonds und Karp angegeben [7].
40
4 Der AbstractMaxFlow-Algorithmus
4.1 Algorithmus
4.1.1 Übertragung auf kantenbasierte Netzwerke
In diesem Abschnitt wollen wir nun die Methode aus Abschnitt 3.2 auf kantenbasierte Netzwerke übertragen, um einen maximalen Fluss zu berechnen. In solchen Netzwerken können
Pfade ezient gesucht werden, so dass wir kein Orakel mehr benötigen und trotzdem für
den Augmentierungsschritt eine polynomielle Laufzeit erhalten.
Mit der Konstruktion aus Satz 2.4.6 kann ein Netzwerk direkt in einen abstrakten Graphen umgewandelt werden; dies rechtfertigt, die grundlegende Idee des Algorithmus direkt
zu übernehmen. Statt Iterationen über sämtliche positiven Pfade werden übliche Suchalgo6
rithmen wie die Breiten- oder Tiefensuche
verwendet, um das Netzwerk zu durchsuchen.
Ebenso werden verletzende Pfade gefunden, die in der pfadbasierten Variante nur von einem Orakel geliefert werden können. Da nicht speziziert ist, welche Pfade das Orakel
O
liefert, gilt Lemma 2.3.4 auch ohne Änderung für in Netzwerken gefundene Pfade.
Sei im Folgenden ein Netzwerk
nicht zwingend maximalen, Fluss
N = (V, E, s, t, c)
mit einem darauf gegebenen gültigen,
φ gegeben. Dabei seien n := |V | und m := |E| die Anzahl
der Knoten beziehungsweise Kanten. Die Kanten im Netzwerk entsprechen den Elementen
im abstrakten Graphen, entsprechend bilden die Mengen
Lφ , Aφ
und
Tφ
eine Partition der
Kanten.
Als Erstes muss die Menge
Lφ
der linkesten saturierten Kanten auf jedem positiven Pfad
initialisiert werden. Diese Menge kann für kantenbasierte Netzwerke von einer abgewandelten Breitensuche bestimmt werden.
Die Suche läuft in zwei Phasen ab. In der Ersten werden alle initialen Kanten in
gefunden, in der zweiten die restlichen saturierten Kanten, also die Menge
Aφ .
Lφ
Jede der
Phasen verhält sich im Wesentlichen wie eine Breitensuche, die sich nur entlang ussführender Kanten orientiert und Kanten ohne Fluss ignoriert. Während der ersten Phase wird
die Suche abgebrochen, sobald eine saturierte Kante gefunden wurde, da eine solche die
linkeste saturierte Kante eines Pfades ist.
6
Nähere Informationen zu diesen Standardalgorithmen wie Breitensuche und Tiefensuche sind zum Beispiel in [24, Kapitel 2.3] zu nden.
41
4 Der AbstractMaxFlow-Algorithmus
Phase 1
7
Zu Beginn wird eine Warteschlange
Q1
mit der Quelle initialisiert und eine
Breitensuche gestartet. Für einen extrahierten Knoten
(v, w)
Q1
in
mit
φ(v, w) > 0
v
werden alle ausgehenden Kanten
betrachtet. Wenn die Kante nicht saturiert war, wird wie üblich
w
eingefügt, falls der Knoten noch nicht markiert worden ist. Falls sie jedoch saturiert
ist, wird die Kante in
Lφ
und
w
in die Schlange
Q2
eingefügt, unabhängig davon, ob der
Knoten bereits markiert worden ist. Es wird jedoch sichergestellt, dass jeder Knoten nur
einmal in
Q2
eingefügt wird. Auÿerdem muss beachtet werden, dass Knoten, die bereits
markiert sind, trotzdem noch Zielknoten neu gefundener Kanten aus
Lφ
sein können (siehe
dazu Abbildung 4.1). Nachdem alle Kanten abgearbeitet worden sind, wird
Phase endet, wenn
Phase 2
Q1
Q2 .
markiert. Die
leer ist.
Q2
Alle Knoten in
auf Basis von
v
werden markiert, anschlieÿend beginnt eine Breitensuche
Es werden auch hier nur ussführende Kanten benutzt und alle noch
gefundenen saturierten Kanten werden zu
Aφ
hinzugefügt.
x
s
v
w
t
Abbildung 4.1: Die dicken Kanten seien saturiert. Während Phase 1 der Bestimmung von Lφ wird
der Knoten w zweimal entdeckt, er darf jedoch nur einmal in Q2 eingefügt werden.
4.1.1 Algorithmus (FindLeftSaturatedEdges).
Eingabe: Ein Netzwerk
N = (V, E, s, t, c)
mit einem Fluss
Ausgabe: Partition der saturierten Kanten in
und
Tφ = ∅.
1
Lφ := Aφ := Tφ := Q1 := Q2 := ∅
2
Enqueue(Q1 , s)
while Q1 6= ∅
v := Dequeue(Q1 )
for e = (v, w) ∈ v + mit φ(e) > 0
markiere e
if e saturiert
Lφ := Lφ ∪ {e}
lastT(e) := ⊥
if w wurde noch nicht in Q2 eingef ü gt
Enqueue(Q1 , w)
else if w nicht markiert
3
4
5
6
7
8
9
10
11
12
7
Lφ , Aφ
φ.
Informationen zur Implementation von Warteschlangen und der Breitensuche mit Warteschlangen nden
sich zum Beispiel in [3, Kapitel 10.1 und 22.2]. Wir verwenden auch die dort angegebenen Notationen:
Mit Enqueue(Q, x) wird ein Element x in eine Schlange Q eingefügt, Dequeue(Q) liefert das nächste
Element in der Schlange.
42
4.1 Algorithmus
markiere w
Enqueue(Q1 , w)
for v ∈ Q2
markiere v
while Q2 6= ∅
v := Dequeue(Q2 )
for e = (v, w) ∈ v + mit φ(e) > 0 und e nicht markiert
if e saturiert
Aφ := Aφ ∪ {e}
if w wurde noch nicht in Q2 eingef ü gt
Enqueue(Q2 , w)
else if w nicht markiert
markiere w
if w wurde noch nicht in Q2 eingef ü gt
Enqueue(Q2 , w)
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
4.1.2 Satz. Algorithmus 4.1.1 initialisiert die Menge Lφ der linkesten Kanten auf jedem
positiven Pfad von s nach t in einem Netzwerk N = (V, E, s, t, c) und ndet eine Partition
Lφ ∪· Aφ ∪· Tφ der saturierten Kanten, wobei Tφ leer ist.
Die Laufzeit beträgt O(|V | + |E|).
Beweis.
Sei
e = (v, w)
die erste saturierte Kante auf einem positiven
(v0 , v1 , v2 , . . . , vk )
also ein kürzester Pfad
alle
in
k∈N
und
s = v0
und
i ∈ {1, 2, . . . , k} die Kanten (vi−1 , vi ) Fluss führen. Die Knoten vi
Q1
eingefügt, bis
vk
extrahiert wird. Anschlieÿend wird
Andersherum wird eine Kante
ist, nicht in
Lφ
e0 ,
vk = v ,
Es existiert
so dass für
werden nacheinander
e betrachtet und in Lφ
eingefügt.
die auf keinem positiven Pfad erste saturierte Kante
eingefügt: Kanten ohne Fluss werden nicht betrachtet. Auf jedem positiven
0
Pfad über e liegt eine saturierte Kante
Knoten werden nicht in
e0
für ein
s-t-Pfad.
Q1
e,
die vorher in
Lφ
eingefügt wird. Die weiteren
eingefügt, so dass die Breitensuche auf jedem Pfad stoppt und
nicht gefunden wird.
In Phase 2 wird die Breitensuche an jeder Kante, die vorher in
Lφ
eingefügt worden ist,
fortgesetzt. Diese Breitensuche arbeitet wie üblich und betrachtet alle erreichbaren Kanten,
die nicht bereits vorher markiert worden sind. Alle gefundenen saturierten Kanten werden
in
Aφ
verschoben, da sie nicht erste saturierte Kanten auf einem Pfad sind.
Jeder Knoten wird genau einmal entweder in
hiert. Die Knoten aus
wenn
Q1
Q2
Q1
oder in
Q2
eingefügt und auch extra-
werden ein weiteres Mal betrachtet, wenn sie markiert werden,
leer ist. Nachdem ein Knoten
v
extrahiert worden ist, werden seine ausgehen-
den Kanten betrachtet und in die Mengen eingeordnet. Diese Iteration kann mit einer
Adjazenzlisten-Datenstruktur in
O(|v + |)
durchgeführt werden. Mit zusätzlichen Variablen
43
4 Der AbstractMaxFlow-Algorithmus
für jeden Knoten kann die Mengenzuordnung und der Test, ob ein Knoten bereits in
Q2
eingefügt worden ist, in konstanter Zeit durchgeführt werden.
Da jeder Knoten und jede Kante konstant oft betrachtet werden, beträgt die Laufzeit
O(|V | + |E|).
Nachdem der Algorithmus ausgeführt worden ist, gilt die Invariante aus Eigenschaft
3.2.4. Das heiÿt jede Kante in
Lφ
ist linkestes Element aus
(Lφ ∪ Aφ )
auf einem
s-t-Pfad.
Nun muss eine kantenbasierte Variante für ReduceL gefunden werden, die doppelte Kanten aus
Lφ
auf positiven Pfaden ndet. Da die positiven Pfade nicht gespeichert werden,
müssen wir solche erst wieder suchen. Auch hierfür verwenden wir eine abgewandelte Breitensuche.
Es sollen alle Kanten aus
Lφ ∪ Aφ ,
werden. Da also die rechtesten
die links einer Kante aus
Lφ
liegen, in
Tφ
verschoben
Lφ -Kanten gesucht werden, beginnt die Breitensuche diesmal
an der Senke und verläuft entlang der eingehenden Kanten (mit positivem Fluss). Die Suche
verläuft dabei in zwei Schleifen, der
Äuÿere Suche
äuÿeren Suche
und der
inneren Suche.
Ausgehend von der Senke wird rückwärts eine Kante
e ∈ Lφ
gesucht.
Knoten mit einer (beliebigen) Markierung werden ignoriert und es werden nur Kanten mit
positivem Fluss benutzt. Sobald eine solche Kante
e
gefunden worden ist, wird ausgehend
von dieser Kante die innere Suche gestartet und anschlieÿend mit den weiteren Kanten
fortgefahren. Abschlieÿend werden betrachtete Knoten mit 1 markiert.
Innere Suche
Sei
v
der Startknoten derjenigen Kante
den wird. Ausgehend von
v
e,
die in der äuÿeren suche gefun-
startet eine zweite Breitensuche. Die Suche verläuft ebenfalls
rückwärts entlang positiver Kanten. Knoten mit Markierung 1 werden in die Suche einbezogen, Knoten mit markierung 2 hingegen nicht. Sobald ein Knoten abgearbeitet worden
s
.
.
.
Tφ
.
.
.
Lφ
.
.
.
Aφ
.
.
.
t
Abbildung 4.2: Anschauliche Einteilung eines Netzwerkes in Tφ , Lφ und Aφ . Die Mengen aus Lφ
sollen den linkesten minimalen Schnitt im Netzwerk darstellen. Links davon liegende saturierte Kanten sind in Tφ , da sie unsaturiert werden können. Die Kanten
rechts von Lφ sind in Aφ , über sie ist noch nichts bekannt. Wenn es einen s-t-Pfad
gibt, der keine Kante in Lφ benutzt, kann die Menge noch keinen Schnitt dargestellt
haben. Der unterste Pfad ist ein verletzender Pfad, der keine Lφ -Kante nutzt.
44
4.1 Algorithmus
ist, erhält er Markierung 2. Sei
wird
in(f ) := e
f
eine gefundene Kante aus
Lφ ∪ Aφ .
Wie in Abschnitt 3.2
gespeichert, um später bei der Pfadsuche darauf zugreifen zu können. Für
jeden Knoten wird die Vorgängerkante, über die er erreicht worden ist, gespeichert. Damit
können, später die Pfade rekonstruiert werden.
Die zwei Markierungen sind notwendig. Eventuell existiert eine
jedoch links einer anderen
Lφ -Kante,
die selbst
Lφ -Kante liegt, die später gefunden wird. In diesem Fall werden
alle links der ersten Kante liegenden Kanten aus
Aφ ∪ Lφ
in
Tφ
verschoben. Da diese Kante
jedoch selbst links einer weiteren Kante liegt, muss sie ebenfalls in
Tφ
verschoben werden
(vgl. Abbildung 4.3).
4.1.3 Algorithmus (ReduceLFromRight).
1
Q1 := Q2 := ∅
2
Enqueue(Q1 , t)
while Q1 6= ∅
v := Dequeue(Q1 )
for e := (u, v) ∈ v − and e nicht markiert
if e saturiert and e ∈ Lφ
Enqueue(Q2 , u)
while Q2 6= ∅
y := Dequeue(Q2 )
for f := (x, y) ∈ t− mit φ(f ) > 0 and f nicht markiert mit 2
if f ∈ Lφ ∪ Aφ
Lφ := Lφ \ {f }
Aφ := Aφ \ {f }
Tφ := Tφ ∪ {f }
Enqueue(Q2 , f )
in(f ) := e
markiere x mit 2
end if
markiere u mit 1
Enqueue(Q1 , u)
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
x
s
···
v
w
y
z
···
t
Abbildung 4.3: Die Kanten (v, w) und (x, y) seien in Lφ . Wenn nach z Knoten w extrahiert wird,
und Vorgänger von (v, w) nach Tφ verschoben worden sind, darf w nicht abschlieÿend markiert werden, da die Kante auch noch bei der Suche nach Lφ -Kanten, die
links von (x, y) liegen, gefunden werden muss.
45
4 Der AbstractMaxFlow-Algorithmus
4.1.4 Satz (Korrektheit von ReduceFromRight). Sei
ein Netzwerk mit einem Fluss φ. Dann ndet Algorithmus 4.1.3 alle Kanten aus Lφ ∪ Aφ die
sich links von saturierten Kanten aus Lφ auf einem positiven Pfad benden und verschiebt
diese nach Tφ .
Die Laufzeit beträgt O(|V | + |E|).
Beweis.
N = (V, E, s, t, c)
Wir beweisen zunächst zwei Behauptungen, aus denen zusammen die Korrektheit
folgt:
Behauptung 1:
Alle auf positiven Pfaden links einer Kante
der inneren Suche gefunden und in
Tφ
e liegenden Kanten werden in
verschoben (falls das nicht bereits vorher geschehen
ist).
Ausgehend von
e
beginnt eine Breitensuche, die alle bisher noch nicht mit 2 markier-
ten Kanten betrachtet. Für eine links von
e
liegende Kante
zwischen den beiden Kanten. Nehmen wir an, dass
f
f
existiert ein positiver Pfad
noch nicht in
Tφ
verschoben worden
ist. Dann wird die Kante über einen positiven Pfad gefunden und mit 2 markiert. Da bei
der Suche alle mit 2 markierten Kanten ignoriert werden, kann eine solche Kante nur dann
nicht gefunden werden, wenn auf jedem der positiven Pfade zwischen
markierte Kante liegt. Dann wäre
Behauptung 2:
Alle Kanten
e,
f
aber bereits vorher in
die rechteste
Lφ -Kante
Tφ
e
und
f
eine solche
verschoben worden.
s-t-Pfad
auf einem positiven
werden vom äuÿeren Algorithmus gefunden, falls sie nicht vorher bereits in
Tφ
sind,
verschoben
worden sind.
Wir nehmen an, dass
e
nicht in
Tφ
liegt, gibt es einen (kürzesten) Weg von
verschoben wird. Da
e zur
e
auf einem positiven Pfad
Senke. Dieser Pfad wird irgendwann von der
äuÿeren Suche gefunden. Die einzige Möglichkeit,
e
nicht zu nden ist, dass alle Wege zur
Senke über mit Kanten führen, die mit Markierung 2 versehen worden sind. Dann ist
wegen Behauptung 1 aber bereits nach
Tφ
verschoben worden.
Aus den Behauptungen folgt: Es wird jedes Paar von Kanten
die auf einem positiven
s-t-Pfad
e
e ∈ Lφ
und
f ∈ L φ ∪ Aφ ,
liegen, gefunden. Nehmen wir an, ein solches Paar würde
nicht gefunden. Das kann passieren, falls die rechts liegende Kante
e
nicht während der
äuÿeren Suche gefunden wird. Nach Behauptung 2 wird die Kante aber gefunden. Wenn
e
einmal gefunden worden ist, wird wegen Behauptung 1 auch die links liegende Kante
f
gefunden.
Durch die Markierungen kann eine Kante, die zunächst in der äuÿeren Suche gefunden
wird, später während einer inneren Suche von einer noch weiter rechts liegenden Kante
gefunden werden.
Jeder Knoten wird, sobald er aus
aus
46
Q1
extrahiert worden ist, mit
1
markiert und wenn er
Q2 extrahiert wird, mit 2. Mit 1 markierte Knoten können noch in Q2 eingefügt werden,
4.1 Algorithmus
aber nicht mehr in
Q1 .
Sobald ein Knoten mit
2
markiert worden ist, wird er in keine
Schlange mehr eingefügt. In jedem extrahierten Knoten werden sämtliche eingehenden
Kanten betrachtet. Insgesamt wird also jeder Knoten und jede Kante nur konstant oft
betrachtet.
Analog zu Denition 3.2.7 nutzen wir die Bezeichnung
Pfad in
verletzender Pfad
für einen
s-t-
N , der keine Lφ -Kanten benutzt. Wenn kein solcher Pfad existiert, war φ maximal.
Im Gegensatz zur pfadbasierten Darstellung können wir in der kantenbasierten Version
einen verletzenden Pfad ezient suchen, ohne ein Orakel zu benutzen. Dazu reicht es, die
Lφ
Kanten aus
s-t-Pfad
aus dem Netzwerk zu entfernen und mit einer beliebigen Pfadsuche einen
zu bestimmen.
4.1.5 Algorithmus.
(FindViolatingPath)
2
V 0 := V
E 0 := E \ Lφ
3
c0 := c|E 0 sei die Einschr ä nkung der Kosten auf E 0
4
N 0 = (V 0 , E 0 , s, t, c0 ) ein neues Netzwerk
5
return ein s - t - Pfad in N 0
1
4.1.6 Satz. Algorithmus 4.1.5 berechnet einen verletzenden Pfad in N , falls es einen gibt.
Die Laufzeit beträgt O(|V | + |M |).
Beweis.
Sei
P
ein verletzender Pfad. Dann benutzt
Da diese Kanten alle noch in
gefunden. Wenn
N
N0
P
nur Kanten, die nicht in
Lφ
sind.
enthalten sind, wird dieser Pfad mit der Pfadsuche in
keinen verletzenden Pfad enthält, ist erst recht keiner in
N0
N0
enthalten.
0
Für den Algorithmus muss das neue Netzwerk N erstellt werden. Dazu müssen im
schlechtesten Fall alle Kanten und Knoten kopiert werden, mit einer geeigneten Datenstruktur genügt es, die Kanten aus
Lφ
zu verstecken. Die Suche nach dem verletzenden
Pfad kann mit Breiten- oder Tiefensuche in
O(|V | + |E|)
durchgeführt werden.
Die Pfadsuche kann im Wesentlichen analog zur Pfadsuche für abstrakte Graphen ablaufen (Algorithmus 3.2.8). In einer Schleife wird so lange ReduceLFromRight und die
Suche nach einem verletzenden Pfad aufgerufen, bis ein Pfad ohne
Aφ -Kante
gefunden
wird, oder bis festgestellt wird, dass der Fluss optimal ist.
Eine gefundene
Aφ -Kante f
auf einem verletzenden Pfad wird in
Lφ
verschoben und
anschlieÿend wird eine neue Iteration gestartet. Falls der Pfad links von
enthält, sei
e die rechteste solcher Kanten. Dann wird der Teilpfad von e nach f
gespeichert. Falls es keine
bis nach
f
f Tφ -Kanten
Tφ -Kanten
links von
f
auf
V
Tφ -Elemente
P in (f )
gibt, wird ein Pfad von der Quelle
gespeichert. Im abstrakten Graphmodell lieferte
einen Pfad auf dem höchstens
als
P in
nach Eigenschaft 3.2.4
liegen.
47
4 Der AbstractMaxFlow-Algorithmus
4.1.7 Algorithmus (FindAugmentablePaths).
N = (V, E, s, t, c)
Lφ ∪· Aφ ∪· Tφ .
Eingabe: Ein Netzwerk
saturierten Kanten
Ausgabe: Ein verletzender Pfad
V
der keine
mit einem Fluss
Aφ -Kanten
do
2
ReduceLFromRight()
V := FindViolatingPath()
if V = ⊥
exit
if V enth ä lt eine Aφ - Kante
f := die linkeste Aφ - Kante auf V
Lφ := Lφ ∪ {f }
Aφ := Aφ \ {f }
if existiert Tφ - Kante links von f auf V
e := die rechteste Tφ - Kante links von f
lastT(f ) := e
P in (f ) := Pfad von e nach f
else
P in (f ) := Pfad von s nach f
while V enth ä lt eine Aφ - Kante
return V
4
5
6
7
8
9
10
11
12
13
14
15
16
17
und die Partition der
enthält.
1
3
φ
4.1.8 Satz. Wenn Algorithmus 4.1.7 abbricht, ist der Fluss φ maximal. Der für eine Kante
f
gespeicherte Pfad P in (f ) enthält keine saturierte Kante.
Der Algorithmus terminiert immer und hat eine Laufzeit von O(|E| · (|V | + |E|)).
Beweis.
Gebe FindViolatingPath keinen verletzenden Pfad zurück. Da vorher Redu-
ceLFromRight ausgeführt worden ist, gelten die Eigenschaften des komplementären
Schlupfes, das heiÿt auf jedem positiven
s-t-Pfad
liegt genau eine Kante aus
Lφ .
Da kein
verletzender Pfad existiert, gibt es keinen (nicht positiven) Pfad, entlang dem der Fluss
augmentiert werden könnte. Es ist also
Lφ
ein minimaler Schnitt und
φ
ein maximaler
Fluss.
Sei nun
V
linkeste. Vor
ein verletzender Pfad, der eine
f
können auf
V
Aφ -Kante enthält. Von diesen Kanten sei f
die
in
nur unsaturierte Kanten und Tφ -Kanten liegen. Als P (f )
wird der Teilpfad von der rechtesten solcher Kanten bis nach
keine saturierte Kante. Falls es keine
Tφ -Kanten
auf
V
f
gespeichert, er enthält also
links von
f
gibt, enthält der ganze
Pfad beginnend von der Quelle keine saturierte Kante.
Die in der Schleife aufgerufenen Algorithmen 4.1.3 und 4.1.5 haben eine Laufzeit von
O(|V | + |E|).
48
Der Algorithmus terminiert, falls entweder kein Pfad gefunden worden ist,
4.1 Algorithmus
oder falls ein Pfad gefunden wurde, der kein
Aφ -Element
wird nochmal durchsucht, er besteht jedoch höchstens aus
enthält. Ein gefundener Pfad
|V | − 1
8
Kanten .
In jedem Schleifendurchlauf, in dem der Algorithmus nicht abbricht, wird eine Kante
aus
Aφ
nach
Lφ
verschoben. Nach höchstens
|Aφ | ≤ |E|
Iterationen wird ein Pfad ohne
Aφ -Kanten gefunden. Die Gesamtlaufzeit ist damit O(|E|·(|V |+|E|)) = O(|E|·|V |+|E|2 ).
Falls der zurückgegebene Pfad
V
keine Kante aus
Tφ
enthält, kann der Fluss wie beim
Algorithmus von Ford und Fulkerson entlang des Pfades direkt augmentiert werden. Ansonsten müssen wir aus Paaren von Kanten aus
zusammensetzen. Für sich schneidende
s-t-Pfad
Lφ
s-t-Pfade
und
Tφ
einen ussvergröÿerndern Pfad
ist es problemlos möglich, einen weiteren
anzugeben, der zunächst auf dem ersten Pfad verläuft und ab der Schnittkante
auf dem zweiten. Auch in diesem Fall ist das Orakel also nicht nötig.
Wir bestimmen zwei Folgen
Pfade von
ek
nach
ik
(ek )
und von
und
ek+1
(ik )
nach
von Kanten aus
ik .
Tφ
beziehungsweise
Lφ ,
sowie
Die Teilpfade werden nur Kanten enthalten,
die nicht saturiert sind, genauso wie in Algorithmus 3.2.9. Das heiÿt, es sei ik
:= in(ek ) und
ek+1 := lastT(ik ). In FindAugmentablePaths werden für e = lastT(f ) die Teilpfade von
e
nach
f
als
P in (f )
gespeichert und können hier verwendet werden. Für die Bestimmung
der Teilpfade zwischen
ek
und
ik
können die Vorgänger, die während der inneren Suche
von ReduceLFromRight gespeichert werden, genutzt werden. Die Teilpfade werden in
einem Array gespeichert.
4.1.9 Algorithmus (CalculateAugmentingPath).
3
k := 0
e1 := rechteste Tφ - Kante auf V
paths[0] := Pfad von e1 bis t
4
do
1
2
5
6
7
8
9
10
11
12
13
8
k := k + 1
ik := in(ek )
paths[2k − 1] := Pfad von ek nach ik
ek+1 := lastT(ik )
if ek+1 6= ⊥
paths[2k] := Pfad von ek+1 nach ik
while ek+1 6= ⊥
` := k
paths[2`] := Pfad von s nach i`
Ein Pfad besteht nach Denition 2.2.7 aus disjunkten Knoten. Es gibt maximal |V | Knoten auf einem
Pfad, zwischen denen |V | − 1 Kanten liegen können.
49
4 Der AbstractMaxFlow-Algorithmus
4.1.10 Satz. Sei j
Algorithmus 4.1.9 berechnet eine Folge von Teilpfaden
Pj , so dass Pfade Pj mit geradem Index j ≡ 0 mod 2 negativ und Pfade Pj mit ungeradem
Index j ≡ 1 mod 2 positiv sind. Insgesamt werden ` positive und ` + 1 negative Pfade
erzeugt.
Die Laufzeit ist O(|V | · |E|).
Beweis.
∈ {0, · · · , 2`}.
Beginnen wir mit ungeradem
j . Dann sind die Pfade Pj
Teilpfade zwischen
ek
und
ik = in(ek ) für ein k . Dieses Kantenpaar wird von ReduceLFromRight gefunden. In der
inneren Suche werden nur Kanten benutzt, deren Fluss echt positiv ist und die während der
Suche gespeicherten Vorgänger liefern einen positiven
ek -ik -Pfad, auf dem Fluss verringert
werden kann.
Sei nun
von
V
ab
j
e1
gerade.
e1 .
Für
ist die linkeste saturierte Kante auf
1 < j < 2`
ist
Pj
der Teilpfad von
V,
und
von der Quelle nach
ek+1
i` .
nach
ik
als Pfad ohne
gespeichert. Der letzte gespeicherte Pfad
P2`
verläuft
e`+1 = ⊥,
das
Tφ -Elemente
vor
Da das Abbruchkriterium erfüllt war, galt vorher
enthielt und damit augmentiert werden kann.
Es gibt insgesamt
`
In FindAug-
P in (ik )
heiÿt in FindAugmentablePaths wurde ein Pfad gefunden, der keine
i`
ist das Teilstück
ek+1 = lastT(ik ).
mentablePaths wird dieses Kantenpaar gefunden und gleichzeitig
saturierte Kanten von
P0
` + 1 = |{0, 2, 4, . . . , 2`}| augmentierbare Pfade und 2` + 1 − (` + 1) =
positive Pfade.
Falls die Teilpfade sich nicht schneiden, können wir den Fluss erhöhen, indem wir ihn
auf positiven Pfaden verringern und auf augmentierbaren Pfaden erhöhen. Da diese Pfade
an der Quelle beginnen und an der Senke enden, wird der Flusswert insgesamt erhöht.
Im Folgenden durchsuchen wir die Pfade (in absteigender Reihenfolge) von der Quelle bis
zur Senke kantenweise. Für jede Kante notieren wir die Position, an der sie das letzte Mal
aufgetaucht ist. Sobald eine Kante mehrmals auftaucht, können die dazwischenliegenden
Kanten entfernt werden. Dadurch werden alle Schleifen in der Pfadmenge entfernt, so dass
am Ende eine kantendisjunkte Menge von Pfaden herauskommt.
Insgesamt haben wir damit den Fluss um mindestens
4.1.11 Algorithmus (RemoveCrossingEdges).
1
2
3
4
5
6
7
8
50
for v ∈ V
o(v) := −1
:=
p
s
o(s) := 0
index := 1
for i := 2` downto 0
pi := paths[i]
for j := 1 to |pi |
1
erhöht.
4.1 Algorithmus
if i mod 2 ≡ 0
e := (u, v) sei die j - te Kante auf pi
else
e := (v, w) sei die (|p| − j) - te Kante auf pj
if o(v) = −1
o(v) := index
p := p + v
index := index + 1
else
for x ∈ pi mit o(x) > o(v)
o(x) := -1
p := p − x
index := o(v) + 1
9
10
11
12
13
14
15
16
17
18
19
20
21
4.1.12 Satz. Algorithmus 4.1.11 berechnet aus der Folge von eventuell nicht disjunkten
Teilpfaden die von Algorithmus 4.1.9 berechnet werden, eine Knotensequenz (v1 , v2 , . . . , vn ),
so dass für zwei aufeinanderfolgende Knoten vi und vi+1 entweder (vi , vi+1 ) oder (vi+1 , vi )
eine Kante in E ist. Im ersten Fall ist φ((vi , vi+1 )) < c((vi , vi+1 )) und im zweiten Fall ist
φ((vi+1 , vi )) > 0.
Die Laufzeit beträgt O(|V | · |M |).
Beweis.
Zur anfangs leeren Sequenz
p
werden nacheinander die Knoten der
2` + 1
Pfade
hinzugefügt. Zwei aufeinanderfolgende Knoten entstammen also diesen Pfaden, die auch
zusätzlich entweder positiv oder augmentierbar sind. Damit der Übergang zwischen den
von CalculateAugmentingPath berechneten Pfaden korrekt ist, werden Pfade mit geradem Index von vorn durchlaufen und Pfade mit ungeradem Index von hinten. Liegt an
den Knoten
(. . . , vi−1 , vi , vi+1 , . . .)
sitiven Pfad vor, ist
ein Übergang von einem augmentierbaren zu einem po-
(vi−1 , vi ) die letzte Kante auf dem augmentierbaren Pfad und (vi+1 , vi )
die letzte Kante auf dem positiven Pfad. Andersherum gilt das Gleiche beim Übergang von
einem positiven zu einem augmentierbaren Pfad.
Zunächst wird für jeden Knoten
i
o(v) := 0 gesetzt. Sobald ein Knoten in die Knotenfolge
p
an Stelle
v
bereits eingefügt worden ist, das heiÿt, es ist
eingefügt wird, wird dieser Index als
Pfad wie
v
o(v) = i
gespeichert. Falls ein Knoten
für ein
i,
werden alle Knoten
i
von dem Pfad entfernt. Für den doppelt betrachteten Knoten
o(v)
nicht. Da der nächste einzufügende Knoten auf dem gleichen
an Positionen gröÿer als
ändert sich der Wert
o(v) := i
lag, bilden zwei aufeinanderfolgende Knoten weiterhin eine Kante aus
E
(vgl.
Abbildung 4.4).
Insgesamt werden höchstens
von
|V |
|E|
Pfade berechnet, von denen jeder eine maximale Länge
hat. Für jeden Pfad wird jeder auf dem Pfad liegende Knoten höchstens zweimal
51
4 Der AbstractMaxFlow-Algorithmus
betrachtet: einmal, wenn er an
p angehängt wird und einmal, falls er wieder entfernt werden
sollte. Die Laufzeit beträgt also
O(|V | · |E|).
Entlang der positiven Kanten kann der Fluss verringert werden, entlang der negativen
erhöht und insgesamt wird der Fluss dadurch gröÿer. Die Algorithmen können in einer
Schleife aufgerufen werden, bis ein maximaler Fluss erreicht ist. Folgender Algorithmus
beschreibt das Vorgehen im Detail:
4.1.13 Algorithmus (Augment).
1
do
2
FindLeftSaturatedEdges()
FindAugmentablePaths()
CalculateAugmentingPath()
RemoveCrossingEdges()
p sei der Pfad entlang dem augmentiert wird
δ := ∞
for e ∈ p
if e positiv
δ := min(δ, c(e) − φ(e))
else
δ := min(δ, φ(e))
for e ∈ p
if e positiv
φ(e) := φ(e) + δ
else
φ(e) := φ(e) − δ
whle δ > 0
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
4.1.14 Satz. Algorithmus
augmentiert schrittweise einen Fluss φ auf einem
Netzwerk N = (V, E, s, t, c) um einen echt positiven Wert δ bis ein maximaler Fluss erreicht
ist.
Augment
w
u
v
i`
Abbildung 4.4: Wechsel zwischen positiven und negativen Pfaden in Algorithmus 4.1.11. Die Kante
(u, v) liegt auf einem positiven Pfad, der nächste Knoten auf dem Pfad ist also
v . Anschlieÿend wird der augmentierbare Pfad von e` nach i` betrachtet, dessen
letzte Kante ist (w, v). Hier muss der Startknoten w als neuer Knoten auf dem
Pfad betrachtet werden.
52
4.1 Algorithmus
Die Laufzeit für eine Augmentierung beträgt O(|E|2 ). Die Gesamtlaufzeit zur Berechnung
eines maximalen Flusses ist O(|E|3 · U ) mit U := max{c(e) | e ∈ E}.
Beweis.
Entlang positiver Teilpfade ist der Fluss
Kanten ist die Residualkapazität
c(e) − φ(e)
φ(e) > 0
echt positiv, entlang negativer
echt positiv. Das Minimum
δ
über diese
Kapazitäten aller Kanten ist auch positiv.
Sei der neue Fluss
φ0
deniert als



 φ(e) − δ
0
φ (e) :=
φ(e) + δ


 φ(e)
Für eine positive Kante
e
e
auf positivem Teilpfad
e
auf augmentierbarem Teilpfad
sonst.
gilt wegen
δ ≤ φ(e)
φ0 (e) = φ(e) − δ ≥ φ(e) − φ(e) = 0.
Wegen
δ ≤ c(e) − φ(e)
gilt für augmentierbare Kanten
e
φ0 (e) = φ(e) + δ ≤ φ(e) + c(e) − φ(e) = c(e).
Nach Lemma 2.2.9 gilt die Flusserhaltung an inneren Knoten der positiven und negativen
Teilpfade. Es bleibt zu zeigen, dass die Flusserhaltung gilt, wenn an einem Knoten negative
und positive Kanten zusammenstoÿen.
Sei
(u0 , . . . , u, v)
(w0 , . . . , w, v) ein negativer Teilpfad, die
0
(v, v ) treen. Der ausgehende Fluss vout (φ0 ) wird durch die
ein positiver Teilpfad und
sich in einer Kante
ik =
Flussänderung nicht verändert, es genügt also zu zeigen, dass
dazu
f := (w, v)
und
g := (u, v)
Def
vin (φ0 ) =
vin (φ) = vin (φ0 )
gilt. Seien
die letzten Kanten auf den Pfaden. Dann gilt
X
φ0 (e)
e∈v −
=
X
φ0 (e) + φ0 (f ) + φ0 (g)
e∈v − \{e,f }
Def
=
X
φ(e) + φ(f ) − δ + φ(g) + δ
e∈v − \{e,f }
=
X
φ(e) + φ(f ) + φ(g)
e∈v − \{e,f }
=
X
φ(e)
e∈v −
Def
= vin (φ)
53
4 Der AbstractMaxFlow-Algorithmus
Sei
v
nun Knoten einer Kante
negativer Pfad
g := (v, u)
(v, w, . . . , w0 )
ek = (v 0 , v)
in dem ein positiver Pfad
beginnen. An
v
ändert sich
vin
(v, u, . . . , u0 )
und ein
f := (v, w)
nicht, mit
und
gilt auÿerdem
Def
vout (φ0 ) =
X
φ0 (e)
e∈v +
X
=
φ0 (e) + φ0 (f ) + φ0 (g)
e∈v + \{e,f }
Def
X
=
φ(e) + φ(f ) − δ + φ(g) + δ
e∈v + \{e,f }
X
=
φ(e) + φ(f ) + φ(g)
e∈v + \{e,f }
=
X
φ(e)
e∈v +
Def
= vout (φ)
Nach Lemma 2.2.9 ändert sich der ausieÿende Fluss in der Quelle um
δ>0
und damit
wächst der Fluss bei einem Aufruf von Augment mindetens um 1.
Nach dem Aufruf von RemoveCrossingEdges hat der Pfad
die Berechnung von
δ
und das Ändern des Flusses kann also in
p keine Kreuzungen mehr,
O(|V |)
durchgeführt wer-
den. In jedem Schleifenaufruf werden nacheinander FindLeftSaturatedEdges(), FindAugmentablePaths(), CalculateAugmentingPath() und RemoveCrossingEdges() aufgerufen, die eine Gesamtlaufzeit von
|V | · U
O(|E|2 )
haben. Der gesamte Fluss ist durch
nach oben beschränkt, so dass der Algorithmus eine Laufzeit von
O(|V | · |E|2 · U )
hat.
4.1.2 Optimierung
Der im letzten Kapitel beschriebene Algorithmus ahmt das Verhalten des pfadbasierten
Algorithmus im Rahmen der Möglichkeiten kantenbasierter Flüsse möglichst genau nach.
Dadurch ist aber insbesondere die Suche nach einem augmentierbaren Pfad in FindAugmentablePaths sehr langsam, da im Worst-Case
Θ(m)-mal sowohl die Suche nach einem
verletzenden Pfad als auch die Entfernung doppelter saturierter Kanten durchgeführt wird.
Dies kann in dichten Graphen mit
m ∈ O(n2 )
sehr lange dauern.
Durch die Nutzung der Breitensuche können wir in einem Schritt mehr Informationen
gewinnen, als es in einer pfadbasierten Variante möglich ist. Dadurch können FindLeftSaturatedEdges und in FindAugmentablePaths angepasst werden.
In FindLeftSaturatedEdges wird die Suche nur entlang positiver Kanten durchgeführt. Betrachten wir den Fall, in dem bei der Pfadsuche mit FindViolatingPath ein
Pfad zurückgegeben wird, der zunächst nur Kanten ohne Fluss benutzt, um dann eine
saturierte Kante aus
54
Aφ
zu benutzen. Dann wird diese Kante in
Lφ
und die links davon
4.1 Algorithmus
liegende
Lφ -Kante
nach
Tφ
verschoben. Solche Kanten können aber direkt in FindLeft-
SaturatedEdges gefunden werden, wenn auch Kanten ohne Fluss benutzt werden.
4.1.15 Algorithmus (FindLeftSaturatedEdgesEx).
Eingabe: Ein Netzwerk
N = (V, E, s, t, c)
mit einem Fluss
Ausgabe: Partition der saturierten Kanten in
L φ , Aφ
und
φ.
Tφ = ∅.
1
Lφ := Aφ := Tφ := Q1 := Q2 := ∅
2
Enqueue(Q1 , s)
while Q1 6= ∅
v := Dequeue(Q1 )
for e = (v, w) ∈ v +
markiere e
if e saturiert
Lφ := Lφ ∪ {e}
lastT(e) := ⊥
if w wurde noch nicht in Q2 eingef ü gt
Enqueue(Q1 , w)
else if w nicht markiert
markiere w
Enqueue(Q1 , w)
for v ∈ Q2
markiere v
while Q2 6= ∅
v := Dequeue(Q2 )
for e = (v, w) ∈ v + nicht markiert
if e saturiert
Aφ := Aφ ∪ {e}
if w wurde noch nicht in Q2 eingef ü gt
Enqueue(Q2 , w)
else if w nicht markiert
markiere w
if w wurde noch nicht in Q2 eingef ü gt
Enqueue(Q2 , w)
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
Mit der gleichen Idee kann auch FindAugmentablePaths abgeändert werden. Jeder
Aufruf von FindViolatingPath ndet einen verletzenden Pfad und die erste saturierte
Kante aus
Aφ
wird nach
Lφ
verschoben. Die Suche nach dem Pfad kann mit einer Breiten-
suche implementiert werden (was gegenüber der Implementierung mit Tiefensuche deutlich
Aφ -Kanten
ge-
ndet) und nach
Lφ
besser ist, siehe dazu Kapitel 4.3). In diesem Fall können direkt alle ersten
funden (genauso, wie FindLeftSaturatedEdges die
Lφ -Kanten
verschoben werden. Alle so gefundenen Kanten lägen auch auf einem verletzenden Pfad.
55
4 Der AbstractMaxFlow-Algorithmus
1/1
1/2
s
v
1/1
1/2
w
x
1/2
y
t
0/2
Abbildung 4.5: Ein Fluss in einem Netzwerk. Die Zahlen geben die Kapazitäten und Restkapazitäten an. Die (x, y) kann direkt in Lφ einsortiert werden, so dass der Algorithmus
im ersten Schritt bereits terminiert. Andernfalls müsste erst der verletzende Pfad
(s, x, y, t) gefunden werden.
Die Breitensuche wird an einer
Aφ -Kante nicht fortgesetzt. Wenn ein Pfad bis zur Senke
gefunden wurde, ist dies ein Pfad der nur
Tφ -Kanten
als saturierte Kanten enthält und er
kann zur Pfadsuche benutzt werden. Die Iteration wird also abgebrochen. Falls keine neuen
Aφ -Kanten und kein Pfad zur Senke gefunden worden sind, ist der aktuelle Fluss maximal.
Andernfalls wird eine neue Iteration gestartet, da durch neue
Tφ -Kanten
eventuell neue
Wege entstanden sein können.
Wenn der Fluss nicht maximal war, wird für jede gefundene
P in (e)
Aφ -Kante e
der Pfad von
Tφ -Kante f enthält,
in
wird nur das rechteste Teilstück ab dieser Tφ Kante als P (e) gespeichert und zusätzlich
lastT(e) := f gespeichert. Damit stehen für jede Kante die Pfade P in und die Kanten lastT
der Quelle zu ihr als
gespeichert. Falls der benutzte Pfad eine
zur Verfügung, so dass CalculateAugmentingPath weiterhin korrekt funktioniert.
4.1.16 Algorithmus (FindAugmentablePaths).
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
56
do
ReduceLFromRight()
Q := ∅
Enqueue(Q, s)
A := ∅
do
v := Dequeue(Q)
for e := (v, w) ∈ v + \ Lφ
markiere v
if e ∈ Aφ
A := A ∪ e
else if w nicht markiert
Enqueue(Q, w)
while Q 6= ∅
for f := (v, w) ∈ A
Lφ := Lφ ∪ f
Aφ := Aφ \ f
if Pfad von s nach f enth ä lt Tφ - Element
e := die rechteste Tφ - Kante auf dem berechneten s - v - Pfad
4.1 Algorithmus
20
lastT(f ) := e
21
P in (f ) := Pfad von e nach f
else
P in (f ) := Pfad von s nach f
end for
if s - t - Pfad V gefunden
return V
else if |A| = 0
exit
while true
22
23
24
25
26
27
28
29
4.1.17 Satz. Wenn Algorithmus 4.1.7 abbricht, ist der Fluss φ maximal. Wenn für eine
Kante f P in (f ) gespeichert wird, enthält der Pfad keine saturierte Kante.
Der Algorithmus terminiert immer und hat eine Laufzeit von O(|E| · (|V | + |E|)).
Beweis.
Wir betrachten die Situation, in der der Algorithmus abbricht. Auf jedem positiven
s-t-Pfad
liegt genau eine Kante aus
kein
Aφ -Element.
Falls
Lφ .
Es wird kein
s-t-Pfad
gefunden und gleichzeitig
Also existiert kein verletzender Pfad und damit ist der Fluss maximal.
Aφ -Kanten
gefunden werden, könnten sie linkeste
Aφ -Kanten
auf einem verletzen-
Lφ
den Pfad sein. Für die Korrektheit schaded es nicht, dass wir diese Kanten in
verschie-
ben, es werden nur zu viele Iterationen durchgeführt. Also werden alle diese Kanten in
verschoben. Die rechteste, auf dem zu einer
wird als
lastT(f )
Aφ -Kante gefundenen Pfad liegende, Tφ
Lφ
Kante
in
gespeichert und dieser Teilpfad als P (f ). Er enthält keine saturierte
Kante, da Kanten aus
Lφ
ignoriert werden.
Die Breitensuche hat eine Laufzeit von
O(|V |).
Abgesehen von
Lφ -Kanten
werden alle
von einem besuchten Knoten ausgehenden Kanten betrachtet. Der Algorithmus bricht ab,
wenn ein verletzender
s-t-Pfad
gefunden worden ist, oder wenn kein
Aφ -Element
gefunden
wurde.
Nehmen wir an, der Algorithmus breche in einer Runde nicht ab. Dann existieren
Elemente, die nach
Lφ
Aφ -
verschoben werden. Wenn in der nächsten Iteration der Schleife
kein neuer Knoten erreicht wird, bricht der Algorithmus ab mit
|A| = 0
und der Fluss war
maximal. Ansonsten wird ein Knoten besucht, der vorher nicht besucht worden ist. Da es
nur
n
Knoten gibt, kann der Algorithmus maximal
Die Laufzeit der Pfadsuche beträgt also
Ein Pfad hat höchstens Länge
|V | − 1,
|V |
Schleifeniterationen durchführen.
O(|V | · |E|).
es können maximal
|E|
Elemente in
werden. Das Speichern aller Pfade kann also insgesamt in Laufzeit
Aφ
gefunden
O(|V |·|E|) durchgeführt
werden.
Die Gesamtlaufzeit des Algorithmus ist damit
O(|V | · |E|).
57
4 Der AbstractMaxFlow-Algorithmus
4.2 Analyse
Pseudopolynomielle Laufzeit
Bei der Übertragung des Algorithmus wird FindViolatingPath benutzt, um einen
verletzenden Pfad zu nden. Die Methode, mit der dieser Pfad gefunden wird, haben wir
dabei nicht weiter festgelegt. Der Algorithmus von Ford und Fulkerson, der die Pfadsuche
ebenfalls nicht einschränkt, hat im schlechtesten Fall pseudopolynomielle Laufzeit. Schon
die Wahl von kürzesten Wegen, wie in Algorithmus 3.1.4, verhindert dies und liefert eine
streng polynomielle Laufzeit.
Betrachten wir zunächst einen Lauf des AbstractMaxFlow-Algorithmus auf dem Beispiel
aus Abbildung 3.4, auf dem der Algorithmus von Ford und Fulkerson
rungsschritte durchführt, wobei
M
Lφ -Kante
(s, 2, t)
(1, 2)
M −1
(1, 2)
(s, 1, t)
(s, 1) und (2, t) in Lφ
Tφ
verschoben. Der Pfad
ist
(2, t).
oder
augmentiert werden kann.
(s, 1) saturiert, einzig möglicher Pfad im dritten
(s, 1, t)
enthält
einsortiert und anschlieÿend
(s, 1)
als
Tφ -Kante
(s, 1) und (1, 2) nach
und die zugehörige
Lφ -Kante
Der Fluss wird also auf der limitierenden Kante zurückgenommen und auf
(1, t)
als
(s, 2, t), entlang dem der Fluss wieder um M − 1 augmentiert werden kann. Nun
werden die Kanten
(s, 2)
um 1 erhöht und ist anschlieÿend maximal.
Im zweiten Fall wird die Kante
des einzig möglichen Pfades
(1, 2)
gefunden, der die limitie-
klassiziert und nicht weiter beachtet. Es wird nun einer der Pfade
Im ersten Fall ist anschlieÿend die Kante
und
(s, 1, 2, t)
mit Kapazität 1 enthält. Im nächsten Schritt wird die Kante
gefunden, entlang denen der Fluss jeweils um
Schritt ist
Augmentie-
eine groÿe Kantenkapazität ist.
Im ungünstigen Fall wird im ersten Schritt der Pfad
rende Kante
O(M )
und
(2, t)
(2, t) saturiert und im nächsten Schritt der Fluss entlang
(s, 1, t)
um
M −1
augmentiert. Nun sind die Kanten
(s, 1),
saturiert und es liegt die gleiche Situation wie im ersten Fall vor.
Es werden also, auch wenn keine kürzesten Wege benutzt werden, maximal vier Augmentierungsschritte durchgeführt, bis ein maximaler Fluss erreicht wird. Dies ist zwar doppelt
so viele, wie nötig sind, führt aber nicht zu pseudopolynomieller Laufzeit. Falls die Pfadsuche immer kürzeste Wege liefert, werden wie vom Algorithmus von Edmonds und Karp
zwei Schritte durchgeführt.
Mit einer kleinen Modikation des Graphen lässt sich jedoch auch für den abstrakten
Algorithmus eine pseudopolynomielle Laufzeit erreichen, auch in dem Fall, in dem nur
kürzeste Wege genutzt werden. Der Graph in Abbildung 4.6 ist eine Version des oben
benutzten Gegenbeispiels mit einigen zusätzlichen Knoten und Kanten. Wenn Multikanten
zulässig sind, genügt es zwei zusätzliche Knoten und Kanten hinzuzufügen.
In diesem Graphen haben alle kürzesten
s-t-Pfade
Länge 5. Die Kante
(1, 2)
sowie die
geschwungenen Kanten haben Einheitskapazitäten, die anderen Kanten haben Kapazität
M 1.
Es existiert dann eine Folge von Augmentierungsschritten, die vom abstrakten
Algorithmus berechnet wird und zu
58
O(M )
Augmentierungsschritten führt.
4.2 Analyse
t1
1
d
a
e
s
t
b
f
c
2
t2
Abbildung 4.6: Ein Graph auf dem M Augmentierungsschritte durchgeführt werden, auch wenn
sämtliche berechneten Teilpfade kürzeste Wege sind.
Die Kanten entlang des Pfades (s, t1 , 1, 2, t2 , t) haben Kapazität 1, die anderen
Kanten haben Kapazität M 1.
Wir nehmen an, dass sämtliche Pfadsuchen kürzeste Wege zurückliefern. Die ersten drei
Pfade können einfach augmentiert werden: Die Pfade
(s, a, 1, 2, f, t)
(s, t1 , 1, d, e, t), (s, b, c, 2, t2 , t)
und
enthalten zunächst alle keine saturierten Kanten und können jeweils mit
maximaler Kapazität von 1 saturiert werden. Im Anschluss führen alle Kanten einen Fluss
von
1.
Zu Beginn des nächsten Augmentierungsschrittes werden die Kanten
als
Tφ -Kanten
klassiziert. Anschlieÿend werde der Pfad
noch saturierte Kanten aus
lastT((t1 , 1)) =
zwischen
2
und
Tφ
enthält. Die letzte
(s, t1 , 1, d, e, t)
Tφ -Kante
verringert und wieder entlang
Im nächsten Schritt ist
(1, d, e, t)
gefunden, der nur
auf dem Pfad ist
(2, t2 ), es wird also Fluss entlang von P in ((2, t2 ))
1
(s, t1 ), (t1 , 1), (1, 2)
(t1 , 1)
= (s, b, c, 2)
und
erhöht,
um eine Einheit erhöht.
(1, 2) unsaturiert, als kürzester Pfad werde diesmal (s, a, 1, 2, f, t)
gefunden; auch entlang dieses Pfades kann der Fluss um 1 erhöht werden. Es liegt nun wieder die gleiche Situation wie nach den ersten drei Augmentierungsschritten vor und es
kann wieder wie beschrieben fortgefahren werden. Indem diese letzten beiden Schritte immer abwechselnd durchgeführt werden, kann der Fluss in
2(M − 1) + 3 Schritten maximiert
werden.
Wir betrachten als nächstes den Graphen aus Abbildung 4.7. Die Kanten
(19, 20)
haben Kapazität 2, die Kante
(2, 9)
(1, 2)
und
habe Kapazität 1. Die anderen Kanten haben
beliebige, aber höhere Kapazität.
Dann kann in drei Augmentierungsschritten ein Fluss mit Wert 3 entstehen. Dazu
wird der Fluss nacheinander auf den Pfaden
(s, 15, 16, 17, 18, 19, 20, t)
(s, 1, 2, 9, 10, 19, 20, t), (s, 1, 2, 3, 4, 5, 6, t)
und
um 1 erhöht. Alle diese Pfade haben eine Länge von 7.
Zu Beginn des vierten Augmentierungsschrittes wird
ebenfalls saturierten Kanten
(1, 2) und (2, 9) nach Tφ
(19, 20) in Lφ
einsortiert, sowie die
verschoben. Der kürzeste verletzende
59
4 Der AbstractMaxFlow-Algorithmus
2
1
2
3
4
5
1
7
s
6
9
8
11
10
15
12
13
t
14
16
17
18
2
19
20
Abbildung 4.7: Ein Graph auf dem M Augmentierungsschritte durchgeführt werden, auch wenn
sämtliche berechneten Teilpfade kürzeste Wege sind.
Die Kanten entlang des Pfades (s, t1 , 1, 2, t2 , t) haben Kapazität 1, die anderen
Kanten haben Kapazität M 1.
Pfad ist dann
(19, 20)
(s, 1, 2, 3, 4, 5, 6, t) der Länge 7, der die Tφ -Kante (1, 2) nutzt. Da in((1, 2)) =
gilt, wird der Fluss wie folgt abgeändert: auf den Pfaden
(s, 15, 16, 17, 18, 19)
und
(2, 3, 4, 5, 6, t) wird er um 1 erhöht und auf dem Pfad (2, 9, 10, 19) wird der Fluss verringert.
Der so benutzte Pfad hat eine Länge von 13.
Zuletzt wird noch der Pfad
(s, 7, 8, 9, 10, 11, 12, 13, 14, t) gefunden, entlang dem der Pfad
augmentiert werden kann. Dieser hat eine Länge von 9. Es gilt also nicht, dass die Länge
der augmentierenden Pfade monoton wächst, wie dies beim Algorithmus von Edmonds und
Karp oder beim Algorithmus von Dinic der Fall ist. Damit können die Laufzeitschranken
nicht übertragen werden.
Das Problem ist, dass zwar alle berechneten Teilpfade kürzeste Pfade sind, das zusammengesetzte Gebilde der positiven und augmentierbaren Kanten zwischen saturierten Kanten aus
Tφ
und
Lφ
muss aber nicht mehr die kürzeste Möglichkeit sein, Fluss zu augmen-
tieren. Eine kleine Änderung im Inneren des Graphen führt dazu, dass Fluss auf der Kante
(9, 10)
zurückgenommen werden muss. Es ist nicht möglich, auf bestimmten Kanten Fluss
zurückzunehmen, sondern nur auf Abschnitten zwischen zwei saturierten Kanten.
Laufzeit für reelle Kapazitäten
Es kann sein, dass der Algorithmus von Ford und Fulkerson nicht terminiert, falls reellwertige Kapazitäten verwendet werden. In [11, Kapitel 1.8] geben sie einen Graphen mit
10 Knoten und 48 Kanten, auf dem der Algorithmus nicht terminiert und der berechnete
Fluss gegen den falschen Wert konvergiert. Kleinere Beispiele entwickelte Zwick [35]. Dort
beschreibt er unter anderem das Netzwerk in Abbildung 4.8, das auch das kleinstmögliche
Netzwerk ist, auf dem der Algorithmus nicht terminiert.
Die Kanten
e1 , e2 , e3
und
e4
seien ausgezeichnete Kanten mit den irrationalen Kapa-
zitäten, deren Wert wir nachher bestimmen. Zuerst wird Fluss über den Pfad
verschickt und dadurch die Kante
60
e4
saturiert. Jeder der Pfade
P1 , P2 , P3
und
(s, 3, 2, t)
P4
nutzt
4.2 Analyse
e1
1
2
e1
1
2
t1
`1
e3
e3
s
s
t
t
e4
3
e4
t2
e2
4
(a) Das Netzwerk auf dem der Algorithmus von
Ford und Fulkerson nicht terminiert.
`2
e2
3
4
(b) Das erweiterte Netzwerk.
Abbildung 4.8: Nicht konvergierendes Beispiel.
eine der ausgezeichneten Kanten als Rückwärtskante. Sie können in dieser Reihenfolge
nacheinander angewendet werden und die Kanten
e4 , e2 , e3
e1
und
werden nacheinander
unsaturiert.
Nehmen wir an, die Kanten
es gelte
c2
Kanten die Kapazitäten
c3
e4
haben Restkapazitäten
Beim Augmentieren von
c1 − c2 , c2 − c2 = 0, c3 − c2
Im nächsten Schritt wird
kapazitäten
c1 , c2 , c3
P1
wird
e4
und
0
und
als Rück-
ist limitierende Kante. Anschlieÿend haben die ausgezeichneten
und
c2 .
Beim Augmentieren von
die limitierende Kante und die neuen Restkapazitäten sind
c2 − c3 .
P4
und
c1 > c2 > c3 > c1 − c2 > c2 − c3 .
wärtskante benutzt und
ist
e1 , e2 , e3
P3
mit Wert
c1 − c2
Kanten die Restkapazitäten
und
augmentiert. Es entstehen die Rest-
c1 − c2 − (c1 − c2 ) = 0, c3 − (c1 − c2 ), c1 − c2
augmentiert und mit der limitierenden Kapazität
c1 − c2 , c3 , c3 − c3
P2
und
c2 − c3
c2 − c3 .
Als letztes wird
haben die ausgezeichneten
c2 − c3 , c3 − (c1 − c2 ), (c1 − c2 ) − (c2 − c3 )
und
0.
Die Kanten
bilden also einen Zyklus und wir sind in der selben Situation wie am Anfang.
Bezeichnen wir die neuen Kapazitäten der Kanten nach diesem Zyklus mit
c02 := −c1 + c2 + c3
und
c03 := c1 − 2c2 + c3

c01


0
c01 := c2 − c3 ,
erfüllen die Kapazitäten das Gleichungssystem
1 −1

 
 c0  =  −1
1
 2  
0
c3
1 −2
 
c1

 

 c2  .
·
1 
 

1
c3
61
4 Der AbstractMaxFlow-Algorithmus
Es ist dann


1 0 0



1 −1
0
 
 

 
det 
1
x ·  0 1 0  −  −1
0 0 1
1 −2


x
−1
1



= det 
1
x
−
1
−1


−1
2 x−1


1 

1
= x3 − 2x2 + x − 1 + 2 + x − 1 + 2x + x − 1
= x3 − 2x2 + 5x − 1 = f (x)
das charakteristische Polynom der Matrix.
9
Nullstelle des Polynoms . Es sei
λ
r :=
λ ≈ 0, 216756572
√
1+ 1−4λ
2
≈ 0, 682327804
ist die eindeutigen reelle
10
. Dann ist
(1, r, r2 )
der zu
gehörende Eigenvektor.
Wir setzen als Kapazitäten
c(e1 ) := 1, c(e2 ) := r, c(e3 ) := r2
und
c(e4 ) := 1.
Nachdem
2
zu Beginn P4 augmentiert wird, haben die Kanten die Restkapazitäten 1, r, r und 0. Damit
1 > r > r2 > 1 − r > r − r2 , so dass wie beschrieben entlang der vier Pfade augmentiert
werden kann. In der ersten Runde wird der Fluss insgesamt um
1+r
erhöht
11
r + r2 + (1 − r) + (r − r2 ) =
.
Nachdem zum ersten Mal entlang der vier Pfade augmentiert worden ist, beträgt die
λn · c(e).
Restkapazität für
e ∈ {e1 , e2 , e3 , e4 } λ · c(e)
wird der Fluss um
λn−1 ·(1+r) erhöht. Der Fluss konvergiert also gegen 1+
und nach
n
Phasen
In jeder Runde
∞
P
λn ·(1+r) =
i=0
1+
1+r
1−λ
= 2 + r + r2 ≈ 3, 147899036,
was auch der maximale Fluss ist.
Da er kürzeste Wege benutzt bestimmt der AbstractMaxFlow-Algorithmus den maximalen Fluss in vier Iterationen. Es wird nacheinander jede der ausgezeichneten Kanten
saturiert und anschlieÿend nicht mehr betrachtet. Wenn das Netzwerk jedoch so abgeändert
wird, wie in Abbildung 4.8 (b), terminiert AbstractMaxFlow ebenfalls nicht.
Wir wollen zeigen, dass er die gleiche Folge von augmentierenden Pfaden erzeugt. Die
Kanten
Länge
t1 , t2 , `1
und
`2
haben jeweils Kapazität
1.
Alle augmentierenden Pfade haben
3. Zu Beginn wird der Fluss entlang der Pfade (s, 1, 2, t) und (s, 3, 4, t) augmentiert,
wobei jeweils die Kanten mit Kapazität 1 benuzt werden. In sämtlichen weiteren Iterationen
werden die Kanten
`1
und
`2
als
Lφ -Kanten
sowie
t1
und
t2
als
Tφ -Kanten
klassifziert.
Wir nehmen an, dass die optimierte Variante genutzt wird, dadurch werden automatisch
alle saturierten Kanten gefunden. Ansonsten müssen die Kanten
passenden verletzenden Pfad in
9
Lφ
`1
und
`2
durch einen
verschoben werden.
Sie lässt sich zum Beispiel mit den cardanischen Formeln bestimmen. Eine numerische Lösung kann mit
dem Newton-Verfahren bestimmen werden.
10
In [35] ist hier ein Tippfehler, die dort angegebene Zahl ist 0, 682378.
11
Hier ndet sich in [35] die falsche Angabe 2 + r.
62
4.2 Analyse
Abhängig davon, ob in ReduceLFromRight zuerst
entweder
in(t1 ) = in(t2 ) = `1
entlang von
(s, 3, 2, t)
oder
augmentiert, wobei
werden. Dazu werde der Pfad
Tφ -Kante t2
(s, 3, 4, t)
benutzt werde. Mit
Anschlieÿend ist
e4
oder
`2
betrachtet wird, ist
Als erster Schritt werde wieder
P1
saturiert wird. Zuerst soll
augmentiert
von der Quelle zur Senke gefunden, wobei die
in(t2 ) = `1
wird der Fluss entlang von
P1
augmentiert.
e2 saturiert. Zum Augmentieren von P2 werde (s, 3, 2, t) als Pfad zur Senke
in(t2 ) = `2 . Mit P in (`2 ) = (s, 2, 4) wird entlang von P2
gefunden. Diesmal sei
Um entlang von
in(t1 ) = in(t2 ) = `2 .
`1
P3
augmentiert.
zu augmentieren, muss der mit der Kante t1 beginnende Pfad
gefunden werden und
in(t1 )
gefunden werden und es sei
muss
`2
sein. Für den letzten Pfad werde der Pfad
(s, 1, 2, t)
(s, 1, 4, t)
in(t1 ) = `1 .
Durch diese Wahl der gefundenen Pfade, die vom Algorithmus durchgeführt werden
kann, wird die beschriebene Folge von Augmentierungen durchgeführt und der Algorithmus
2
terminiert nicht. Der erreichte Fluss ist um
höher, da es zwei zusätzliche Pfade mit
Kapazität 1 gibt. Das Netzwerk enthält Mehrfachkanten, um es einfach zu halten. Mit
zusätzlichen Knoten, wie im Netzwerk aus Abbildung 4.6, kann das Verfahren auch auf
einfachen Graphen angewendet werden.
Laufzeit der Pfadsuche
Wir wissen nun, dass die Gesamtlaufzeit pseudopolynomiell ist und wollen als nächstes
überprüfen, wieviele Suchen nach verletzenden Pfaden (in der Standardversion) durchgeführt werden müssen. Wir betrachten dazu einen Graphen wie in Abbildung 4.9. Für
n ∈ N
hat das Netzwerk jeweils
n
Knoten
i ∈ {0, 1, . . . , n − 1}
gibt es die Kanten
zusätzlich die Kanten
(xi , yi−1 ).
x0 , x1 , . . . , xn−1
(s, xi ), (xi , yi )
Insgesamt gibt es
2n + 2
und
und
y0 , y1 , . . . , yn−1 .
(yi , t).
Knoten und
Für
i > 0
4n − 1
Für
gibt es
Kanten. Alle
Kanten haben Einheitskapazität.
xn−1
xn−2
s
..
x1
x0
.
yn−1
yn−2
t
y1
y0
Abbildung 4.9: Eine Graphklasse auf der mit m Kanten O(m) Pfadsuchen durchgeführt werden.
63
4 Der AbstractMaxFlow-Algorithmus
Der maximale Fluss im Netzwerk ist
werden, indem nacheinander die Pfade
n
und kann in
(s, x0 , y0 , t)
n
bis
Augmentierungsschritten erreicht
(s, xn−1 , yn−1 , t)
augmentiert wer-
den.
Wir betrachten nun den Fall, dass stattdessen in den ersten
n−1
Schritten die Pfade
(s, x1 , y0 , t) bis (s, xn−1 , yn−2 , t) gewählt worden sind. Algorithmen, die Residualnetzwerke
benutzen, können den Fluss nun entlang des Pfades
yn−1 , t)
Im
(s, x0 , y0 , x1 , y1 , . . . , xn−1 , yn−2 , xn−1 ,
augmentieren und erreichen so einen maximalen Fluss.
n-ten
Augmentierungsschritt von AbstractMaxFlow werden
i-ten
FindAugmentablePaths durchgeführt. In der
n−1
Iteration wird die Kante
als am weitesten rechts auf einem verletzenden Pfad liegende Kante in
nächsten Schritt können dann die Kanten
(s, xi )
und
Iterationen in
(xi , yi−1 )
in
Tφ
Lφ
(xi−1 , t)
verschoben. Im
verschoben werden.
In diesem Beispiel ist die Laufzeit des Algorithmus um den Faktor zwei gröÿer und die
Anzahl der Kanten ist in der selben Gröÿenordnung wie die Anzahl der Knoten. Die Anzahl
der Iterationen in FindAugmentablePaths ist begrenzt durch die Anzahl der saturierten
Kanten. Die Laufzeit vom AbstractMaxFlow-Algorithmus ist nur um einen Faktor
gröÿer, wenn jede gefundene saturierte Kante vorher entlang eines Pfades augmentiert
worden ist.
4.2.1 Satz. In einem Netzwerk mit
n
Augmentierungsschritten zu saturieren.
Beweis.
sei
√
Knoten ist es möglich, Ω(n · n) Kanten mit n
Wir betrachten einen vollständigen Graphen mit
n Knoten {1, 2, · · · , n}. Für i < j
(i, j) eine Kante, das heiÿt, alle Kanten verlaufen von Knoten mit niedriger Nummer zu
Knoten mit hoher Nummer (vgl.. Denition 4.3.1). In Bemerkung 3.2.1 haben wir gezeigt,
dass in solchen Graphen exponentiell viele Pfade existieren. Wir wollen nun zeigen, dass
mit
n Augmentierungsschritten (für groÿes n) mindestens n·
p
(n) Kanten saturiert werden
können.
Wir sagen eine Kante
e
überbrückt ` Knoten, falls e = (i, j) ist und j − i = ` gilt. Zum
Beispiel überbrückt die Kante
Wir wollen für wachsendes
(3, 5)
zwei Knoten.
i nacheinander alle Kanten nutzen, die i Knoten überbrücken.
Sei zunächst
i = 1. Der Pfad (1, 2, . . . , n) nutzt alle Kanten die einen Knoten überbrücken.
n−1
Das sind
i
=
n−1
1
Wir setzen nun
=n−1
i = 2.
können, und der Pfad
1
Stück.
Wenn nur Kanten, die zwei Knoten überbrücken genutzt werden
beginnt, werden die Kanten
(1, 3, 5, . . .)
benutzt. Falls
n=1≡2
ist, muss die letzte Kante zum ausgleich benutzt werden. Andersrum können, falls die
Kante
(1, 2)
genutzt wird, die Knoten
(2, 4, 5, . . .)
besucht werden. Mit diesen zwei Pfaden
wurden also alle Kanten, die zwei Knoten überspringen, genutzt.
i Pfade benötigt, um alle Kanten, die i Knoten übersprin n−1 gen, zu nutzen. Der in 1 startende Pfad nutzt
Kanten. Ein Pfad, der ab Knoten j die
ij
k
n−j
Kanten nutzt, die i Knoten überspringen, nutzt
Kanten, die i Knoten überbrücken.
i
Insgesamt werden auf diese Art
64
4.2 Analyse
1
2
3
4
5
6
Abbildung 4.10: Ein Graph mit 6 Knoten. Die zwei Pfade mit den roten Kanten nutzen jeweils
6−1 = 6−2
= 2 neue Kanten. Die blauen Pfade nutzen 6−1
= 6−2
=
2
2
3
3
6−3 = 1 neue Kante. Insgesamt werden 5 + 2 + 2 + 1 + 1 + 1 = 12 Kanten
3
genutzt.
Wir wollen die Anzahl der Kanten, die insgesamt in
werden, bestimmen. Es werden
1+2+3+4+···
überbrücken, hinzugefügt. Da sich
n
n
Augmentierungsschritten genutzt
Pfade, die die gleiche Anzahl an Knoten
nicht immer als Summe aufeinanderfolgender Zahlen
darstellen lässt, müssen eventuell von den letzten Pfaden einige ausgelassen werden. Abbildung 4.10 zeigt ein Beispiel für
n = 6 = 1 + 2 + 3,
so dass es genau aufgeht. Für
1, 2
können dieselben Pfade genutzt werden. Damit werden alle Kanten genutzt, die
3
Knoten überbrücken. Es kann jedoch nur einer der möglichen vier Pfade, die
überbrücken, genutzt werden. Dies ist erst für
n = 10
gegeben mit
n =
darstellen. Wenn man dies nach
mit
k > 0.
k
n
als Summe der ersten
auöst, gilt
4
und
Knoten
möglich.
Da die Summe der benutzten Kanten monoton wächst, sei ab jetzt immer
k·(k+1)
. Dann lässt sich
2
n=7
k = − 12 ±
q
1
4
+ 2n.
k
n
und
k
natürlichen Zahlen
Wir nutzen die Lösung
Es gilt dann
lim k
n→∞
1
= lim − +
n→∞ 2
√ √
= 2 · n.
r
1
+ 2n
4
Wir schätzen nun die Anzahl der benutzten Kanten ab:
k X
i X
n−j
i
i=1 j=1
≥
k X
i
X
n−j
i=1 j=1
i
−1

i
X
1
−i +
=
n − j
i
i=1
j=1



k
i
X
X
−i + 1 i · n −
=
j 
i
k
X
i=1

j=1
65
4 Der AbstractMaxFlow-Algorithmus
k X
1
i(i + 1)
−i +
i·n−
i
2
i=1
k X
i
1
=
−i + n − −
2 2
=
i=1
k
1
3X
= k · (n − ) −
i
2
2
i=1
1
= k · (n − ) −
2
1
Def
= k · (n − ) −
2
3 k(k + 1)
·
2
2
3
n
2
(4.1)
Damit gilt für groÿe
n:
3
1
lim k · (n − ) − n
2
2
√ √
1
3
= lim 2 · n · (n − ) − n
n→∞
2
2
√ √
= 2· n·n
n→∞
Die Kapazitäten für alle benutzten Kanten, die mehr als einen Knoten überbrücken, wird
auf
1
sind
gesetzt, die Kapazität der Kanten, die mehrmals benutzt werden, sei passend. Dann
Ω(n ·
√
n)
Kanten saturiert.
Wir betrachten nun einen Graphen mit
Graphen mit
n
n+2
Knoten, der aus einem vollständigen
Knoten und zwei zusätzlichen Knoten als Quelle und Senke besteht, wie in
i ∈ {1, 2, . . . , n} die Kanten (s, i)
√
werden Ω(n ·
n) Kanten saturiert.
Denition 4.3.1. Zusätzlich gebe es für
ersten
n
Augmentierungsschritten
Der nicht optimierte abstrakte Fluss-Algorithmus klassiziert alle in
als
Lφ -Kanten.
θ(n ·
(i, t).
In den
1 startenden Kanten
In der anschlieÿenden Pfadsuche können alle anderen saturierten Kanten
jeweils einzeln sukzessive
insgesamt
und
√
n)
Aφ -Kante
auf einem verletzenden Pfad gefunden werden, so dass
Phasen durchgeführt werden.
Der optimierte Algorithmus ndet in einer Iteration alle saturierten Kanten und verschiebt sie in
Lφ
(beziehungsweise
Tφ ).
4.3 Empirische Ergebnisse
Implementierung
Zum experimentellen Testen der Güte des abstrakten Fluss-Algorithmus
wurde er in mehreren Varianten implementiert in Java implementiert. Die in Abschnitt 3.1
vorgestellten Algorithmen wurden ebenfalls implementiert.
66
4.3 Empirische Ergebnisse
Als Grundlage wurde eine objektorientierte Datenstruktur für Graphen implementiert,
die es ermöglicht unter einer Schnittstelle mehrere Ansätze zur Verfügung zu stellen. In der
gewählten Implementierung besteht ein Graph aus einer Menge von Knoten und Kanten,
die beide in einem Array gespeichert werden. Sie können beide direkt über eine Identikationsnummer angesprochen werden. Die Knoten verwalten Adjazenzlisten, die sowohl
eingehende als auch ausgehende Kanten speichern.
Es wurden zwei Varianten implementiert, eine auf einem Array und eine auf
Bäumen
basierende
12
Rot-Schwarz-
. Diese beiden Varianten unterstützen das Durchlaufen aller adjazen-
ten Kanten (oder Knoten) in der gespeicherten Reihenfolge. Das Suchen einer Kante, von
der nur der Start- und Endknoten bekannt sind, erfordert in der array-basierten Datenstruktur lineare Zeit in der Anzahl der adjazenten Knoten und in der baum-basierten Datenstruktur nur logarithmische Zeit. Zusätzlich wurde eine Variante der array-basierenden
Knotendatenstruktur implementiert, mit der die adjazenten Kanten in zufälliger Reihenfolge durchlaufen werden können.
Wie in Abschnitt 3.1 und 4.2 gezeigt, haben sowohl der Ford und Fulkerson-Algorithmus
als auch der Abstrakte Fluss-Algorithmus eine pseudopolynomielle Worst-Case-Laufzeit,
wenn eine schlechte Folge von augmentierenden Pfaden gewählt wird. Mit der randomisierten Datenstruktur kann geprüft werden, ob die Eekte durch zufällige Wahl der Pfade
gemildert werden können.
Als Suchalgorithmen wurden eine Breitensuche und eine Tiefensuche implementiert, die
jeweils die besuchten Vorgänger markieren. Beide Algorithmen entsprechen damit den Bedingungen für den Markierungsalgorithmus nach Ford und Fulkerson. Der Algorithmus
von Ford und Fulkerson wurde mit der Tiefensuche als Pfadsuche implementiert und der
Algorithmus von Edmonds und Karp mit der Breitensuche.
Der Abstrakte Fluss-Algorithmus wurde in drei Varianten implementiert. Die ersten beiden Varianten entsprechen dem in Abschnitt 4.1.1 beschriebenen Algorithmus: Abstract
benutzt zur Pfadsuche in FindViolatingPath eine Tiefensuche und AbstractSP nutzt
eine Breitensuche und damit kürzeste Pfade. Die in Abschnitt 4.1.2 beschriebenen Verbesserungen wurden in AbstractOpt implementiert.
Der Ford und Fulkerson-Algorithmus ist als FordFulkerson und der Algorithmus von
Edmonds und Karp als EdmondsKarp implmentiert.
Zum Laden und Speichern von Dateien mit Netzwerken im Format für maximale Flüsse der ersten DIMACS-Challenge wurde ein Konverter geschrieben. Dies erlaubt die von
den bei der DIMACS-Challenge erzeugten Graphgeneratoren zu nutzen. Zusätzlich wurden einige Graphgeneratoren neu implementiert. Diese können nun nicht nur Dateien im
DIMACS-Format schreiben, sondern die Graphen direkt im internen Format erzeugen.
12
Als Spezialfall von B-Bäumen sind Rot-Schwarz-Bäume binäre Suchbäume, die annähernd balanciert
sind (vgl. [3, Kapitel 13,18]).
67
4 Der AbstractMaxFlow-Algorithmus
13
Die erzeugten Klassen stehen als freie Software unter der GPL-Lizenz Version 3
Testinstanzen
.
Zum Vergleichen der Algorithmen nutzen wir drei Graphklassen. Die er-
ste Graphklasse bestehen im Wesentlichen aus einem vollständigen gerichteten Graphen
und zwei zusätzlichen Knoten. Für die Kanten lassen wir Zufallszahlen in verschiedener
Verteilung zu, solange sie ganzzahlige Werte erzeugen.
4.3.1 Denition (Kn ).
Sei
n ∈ N
und für
c1 , c2 ∈ N
diskrete Wahrscheinlichkeitsverteilung, die Werte von
V := {s, v1 , v2 , . . . , vn , t}
ten ist deniert als
c1
mit
bis
c2
c1 > c2
sei
D(c1 , c2 )
eine
liefert. Die Menge der Kno-
und die Menge der Kanten ist deniert als
E := {(vi , vj ) | vi , vj ∈ V ∧ i < j} ∪ {(s, v1 ), (vn , t)}.
Die Kapazitäten sind deniert als


e = (s, v1 )

 n · c2
c(e) :=
D(c1 , c2 ) e ∈ E \ {(s, v1 ), (vn , t)}


 n·c
e = (vn , t)
2
Eine Instanz
Kn
Die Instanzen
ist ein Netzwerk
Kn
bestehen (bis auf die zwei Kanten
ständigen gerichteten Graphen mit
damit
azyklisch.
N = (V, E, v1 , vn , c).
n
(s, v1 )
und
(vn , t))
aus einem voll-
Knoten und vorwärtsgerichteten Kanten und sind
Diese Klasse stellt für Algorithmen, deren Laufzeit von der Anzahl der
Kanten abhängt, die schwierigsten Instanzen. Ein Beispiel für diese Klasse ist in Abbildung
4.11 zu sehen.
s
1
2
3
4
5
6
7
t
Abbildung 4.11: Ein Beispielgraph der Klasse K7 .
Ein weiterer Typ von Instanzen ist RMFGEN, die in [14] und in mehreren Vergleichen
bei der DIMACS-Challenge [21] benutzt werden.
13
Der Originaltext ist unter der Adresse http://www.gnu.org/licenses/gpl.html zu nden, eine deutsche
Übersetzung unter http://www.gnu.de/documents/gpl-3.0.de.html.
68
4.3 Empirische Ergebnisse
4.3.2 Denition (RM F GEN ).
deniere
Vi := {vjk | 1 ≤ j, k ≤ a}.
Sei
a, b, c1 , c2 ∈ N
und
c2 > c1 .
i ∈ {1, 2, . . . , b}
b
S
als V :=
Vi .
Für
Die Menge der Knoten ist deniert
i=1
Deniere
Ei := {(vijk , vij 0 k0 ) | vijk , vij 0 k0 ∈ Vi ∧ |j − j 0 | = 1 ∧ |k − k 0 | = 1}.
{1, 2, . . . , b − 1}
sei
2
2
π` : {1, 2, . . . , a} → {1, 2, . . . , a}
eine Permutation. Deniere damit
E`0
:= {(v`jk , v`+1π` (jk) ) | v`jk ∈ Vi ∧ v`+1π` jk ∈ V`+1 }. Die Menge der Kanten
b
b−1
S
S 0
E` . Die Kapazitäten sind randomisiert14 deniert als
als E :=
Ei ∪
i=1
` ∈
Für
ist deniert
`=1
(
c22
c(e) :=
Eine Instanz
RMFGEN(a, b)
e ∈ Ei
U (c1 , c2 ) e ∈ E`0
ist ein Netzwerk
N = (V, E, v111 , vbaa , c).
Die Graphen sind in mehreren Schichten mit jeweils
a2
Knoten angeordnet, jeweils zwei
2
aufeinanderfolgende Schichten werden mit a Kanten verbunden. Sie haben damit eine
relativ hohe Anzahl von Kanten, die aber noch linear in der Anzahl der Knoten ist. Diese
Instanzen repräsentieren damit dünne Graphen mit relativ vielen Kanten. Insgesamt hat
eine RMFGEN(a, b)-Instanz
a2 ·b Knoten und 4b·(a2 −a)+(b−1)∗a2
Eingangs- und Ausgangsgrad ist jeweils
Kanten. Der höchste
5. Ein Beispielnetzwerk für a = 3 ist in Abbildung
4.12 zu sehen.
Eine dritte Instanz ist die Variante
Mesh
des Washington-Generators, die ebenfalls bei
der DIMACS-Challenge vorgestellt worden ist.
4.3.3 Denition (Washinton-Mesh).
{1, 2, . . . , d1 }, j ∈ {1, 2, . . . , d2 }} ∪ {s, t}
k + 1 mod d2
und
d1 , d2 ≥ 3 ∈ N.
Sei
Dann ist
die Menge der Knoten. Es sei
se (k) := k − 1 mod d2 .
V := {vij | i ∈
s1 (k) := k , s2 (k) :=
Dann ist die Menge der Kanten deniert als
E := {(s, i) | i ∈ {1, 2, . . . , d1 }} ∪{(vij , vi+1,s1 (j) ) | i ∈ {1, 2, . . . , d2 − 1}, j ∈ {1, 2, . . . , d1 }}
∪{(vij , vi+1,s2 (j) ) | i ∈ {1, 2, . . . , d2 − 1}, j ∈ {1, 2, . . . , d1 }} ∪{(vij , vi+1,s3 (j) ) | i ∈ {1, 2, . . . ,
d2 − 1}, j ∈ {1, 2, . . . , d1 }} ∪{(i, t) | i ∈ {1, 2, . . . , d1 }}.
Die Kapazitäten
einer diskreten Wahrscheinlichkeitsverteilung zugewiesen. Dann ist
Instanz von
c
werden gemäÿ
N = (V, E, s, t, c)
eine
Washington-Mesh.
Eine Washington-Mesh-Instanz besteht aus
d1 · d2
Knoten (zuzüglich Quelle und Senke),
die auf einem Gitter liegen. Es gibt Kanten zwischen benachbarten Schichten von der Quelle
in Richtung Senke. Jeder Knoten hat drei Nachfolger: denjenigen an seiner Position in der
nächsten Ebene, sowie den darüber und darunter. Diese werden durch die Methoden
s2
und
s3
s1 ,
bestimmt. An den Rändern des Gitters wird umgebrochen, so dass die oberen
Knoten mit den unteren verbunden sind, und umgekehrt.
Washington-Mesh-Graphen sind dünne, azyklische Graphen.
14
Mit U (x, y) wird eine diskrete Gleichverteilung der Zahlen von x bis y bezeichnet.
69
4 Der AbstractMaxFlow-Algorithmus
Ebene 1
Ebene 2
Ebene
···
Abbildung 4.12: Ein Beispielgraph der Klasse RMFGEN mit a = 3. Es gibt b Ebenen mit jeweils
a2 Knoten, die untereinander zu einem Gitter verbunden sind. Die Knoten auf
benachbarten Ebenen werden randomisiert mit a2 Kanten verbunden. Die Quelle
ist grün, die Senke rot.
Tests
Zuerst überprüfen wir, wie die Laufzeiteigenschaften der unterschiedlichen Imple-
mentierungen der Adjazenzlisten sind. Wir nutzen dazu EdmondsKarp als Vergleichsalgorithmus, da seine Laufzeit unabhängig von der Kantenkapazität ist. Es wurden für die
array-basierte, baum-basierte und randomisierte Version je 250 Durchläufe auf den Instanzen
K1
bis
K200
durchgeführt. Abbildung 4.14 zeigt die Ergebnisse.
Mit der array-basierte Datenstruktur ist die Laufzeit am niedrigsten, gefolgt von der
Variante mit dem Baum. Die langsamste Variante ist die randomisierte. Dies ist einerseits
darauf zurückzuführen, dass durch die zufällige Wahl der nächsten Nachbarn ein Overhead
entsteht. Andererseits besucht der Algorithmus von Edmonds und Karp die Knoten bereits
in optimaler Reihenfolge.
Alle folgenden Versuche werden nur mit der array-basierten Datenstruktur durchgeführt,
sowie nicht anders gesagt wird. Es werden jedoch auch noch weitere Versuche mit randomisierten Algorithmen durchgeführt.
Nun werden die verschiedenen Algorithmen untereinander verglichen. Als ersten Test vergleichen wir die die Algorithmen EdmondsKarp, FordFulkerson, Abs, AbsSP und
70
b
4.3 Empirische Ergebnisse
s
v11
v21
v31
v41
v12
v22
v32
v42
v13
v23
v33
v43
v14
v24
v34
v44
v15
v25
v35
v45
t
Abbildung 4.13: Ein Beispiel einer Washington-Mesh-Instanz mit d1 = 5 Knoten pro Schicht und
d2 = 4 Schichten.
EdmondsKarp mit Array
EdmondsKarp mit Baum
EdmondsKarp randomisiert
7
6
Zeit (s)
5
4
3
2
1
0
20
40
60
80
100
120
140
160
180
Anzahl Knoten
Abbildung 4.14: Einuss der Graph-Datenstruktur auf den Edmonds-Karp-Algorithmus.
AbsOpt auf den vollständigen Graphen. Die maximale Knotenkapazität ist
500,
sobald
ein Algorithmus jedoch mehr als acht Sekunden für das berechnen einer Instanz benötigte,
wurde er nicht mehr auf gröÿere Instanzen angewendet. Die Kantenkapazitäten sind in diesem Test gleichverteilt von
1 bis 1000. Für jede Instanz wurden 5 Durchläufe durchgeführt.
Die Ergebnisse dieses Experiments sind in Abbildung 4.15 zu sehen.
Der Algorithmus von Edmonds und Karp schneidet am besten ab, der nicht auf kürzesten
Wegen beruhende Algorithmus von Ford und Fulkerson ist hier deutlich schlechter.
Das gleiche Bild zeigt sich bei AbstractMaxFlowSP und AbstractMaxFlow.
Hier ist die Variante mit kürzesten Wegen deutlich schneller als die Variante, die beliebige verletzende Pfade nutzt. Es zeigt sich auÿerdem, dass die Laufzeit von Abstract-
71
4 Der AbstractMaxFlow-Algorithmus
MaxFlowSP starken Schwankungen unterliegt und für einzelne Läufe unter der Laufzeit
von FordFulkerson liegt.
Deutlich schneller, als FordFulkerson, aber noch nicht so gut, wie EdmondsKarp,
ist AbstractMaxFlowOpt. Hier zeigt sich, dass die Optimierungen aus Abschnitt 4.1.2
die Laufzeit tatsächlich deutlich verbessern.
FordFulkerson
EdmondsKarp
Abstract
AbstractSP
AbstractOpt
7
6
Zeit (s)
5
4
3
2
1
0
50
100
150
200
250
300
350
400
450
Anzahl Knoten
Abbildung 4.15: Vergleich der verschiedenen Algorithmen mit der array-basierten Adjazenzliste.
Alle Instanzen sind vollständige Graphen.
Schwieriger ist die Lage bei den RMFGEN-Instanzen. Die Algorithmen wurden auf 6
Instanzen getestet, die in [2] benutzt werden. Drei dieser Instanzen sind sogenannte
breite
Instanzen, die aus wenigen Ebenen bestehen, aber in einer Ebene viele Knoten enthalten.
Die anderen drei Instanzen sind sogenannte lange Instanzen, die viele Ebenen enthalten,
aber in jeder Ebene relativ wenig Knoten. Die Parameter sind so gewählt, dass die breiten
und langen Instanzen jeweils etwa gleich viele Knoten und Kanten enthalten. Die Kantenkapazität ist gleichverteilt zufällig aus dem Bereich von 0 bis 10000.
Auf beiden Klassen ist EdmondsKarp der beste Algorithmus, wie zu erwarten war. Auf
den breiten Instanzen ist jedoch der Algorithmus von Ford und Fulkerson deutlich besser
als der abstrakte Algorithmus, auch in der optimierten Version. Bei den langen Instanzen
ist die Reihenfolge genauso, wie bei den vollständigen Graphen. Auf sämtlichen Instanzen
wurden 30 Durchläufe durchgeführt. Die Ergebnisse sind in der folgenden Tabelle zu sehen.
Die Laufzeiten sind in Sekunden angegeben:
72
4.3 Empirische Ergebnisse
Knoten
Kanten
EdmondsK.
FordFulk.
AbsOpt
RMFGEN(16, 4)
1024
4608
0,57
1,98
14,58
RMFGEN(21, 5)
2205
10146
4,40
129,97
200,29
RMFGEN(28, 5)
3920
18256
16,71
320,38
1587,02
RMFGEN(6, 31)
1116
4800
0,53
8,00
5,84
RMFGEN(7, 42)
2058
9065
2,65
105,67
42,16
RMFGEN(8, 64)
4096
18368
12,64
653,68
289,70
Auf den Washington-Mesh-Graphen verhalten sich die Algoritmen so, wie auf den vollständigen Graphen und den langen RMFGEN-Instanzen. Getestet wurden Graphen mit
d1 ∈ {3, 4, 5, 6, 7, 8}
und
d2
von
3
bis
100.
Dabei wurden für jede Instanz 50 Durchläufe
durchgeführt. Das Ergebnis ist in Abbildung 4.16 zu sehen.
FordFulkerson
EdmondsKarp
AbstractOpt
7
6
Zeit (s)
5
4
3
2
1
0
d1 = 3
d1 = 4
d1 = 5
d1 = 6
d1 = 7
d1 = 8
Instanzen, d2 jeweils von 3 bis 100.
Abbildung 4.16: Vergleich der verschiedenen Algorithmen mit der array-basierten Adjazenzliste auf
den Washington-Mesh-Graphen.
In einem nächsten Schritt wurden die randomisierten Versionen der abstrakten Algorithmen getestet. Hier wurden die gleichen Instanzen und Parameter wie beim obigen Test
mit vollständigen Graphen verwendet.
Das Ergebnis ist ziemlich eindeutig. Für den abstrakten Algorithmus ohne Optimierung,
tritt die enorme Verschlechterung erst später ein, am generellen Verlauf der Kurve ändert sich jedoch nichts. Die Laufzeit des optimierten Algorithmus verschlechtert sich ein
bisschen, er bleibt aber noch schneller als FordFulkerson.
73
4 Der AbstractMaxFlow-Algorithmus
FordFulkerson
EdmondsKarp
Abstract
Abstract(rnd)
AbstractOpt
AbstractOpt(rnd)
7
6
Zeit (s)
5
4
3
2
1
0
50
100
150
200
250
300
350
400
450
Anzahl Knoten
Abbildung 4.17: Vergleich der Algorithmen zwischen der array-basierten Adjazenzliste und der
randomisierten. Alle Instanzen sind vollständige Graphen.
Ein weiterer Test überprüft, wie stark sich die Pseudopolynomialität auswirkt. Die Analyse hat ergeben, dass der Abstrakte Flussalgorithmus pseudopolynomiell ist. Auf den
Standardbeispielen, auf denen der Algorithmus von Ford und Fulkerson pseudopolynomielles Verhalten zeigt, läuft er allerdings schneller. Als Testinstanz dient ein
K100 ,
dessen
Kantenkapazitäten ansteigen. Sie beginnen bei konstant 1. Die maximalen Kapazitäten
√
werden nacheindander um den Faktor
2
erhöht, bis der Wertebereich überschritten ist.
Die minimalen Kapazitäten wachsen langsamer, aber ebenfalls exponentiell, bis 8192. Es
wurden jeweils 100 Instanzen generiert, auf denen die Algorithmen getestet worden sind.
Das Ergebnis ist in Abbildung 4.18 zu sehen.
Es zeigt sich, dass die Laufzeit von FordFulkerson stark wächst, während die Laufzeit
AbstractOpt zu Beginn langsam wächst und anschlieÿend fast Konstant bleibt. Die
Laufzeit von EdmondsKarp ist quasi Konstant, egal welche Kapazitäten genutzt werden,
was auch so erwartet wird.
Der letzte Test zeigt, wie sich die Anzahl der Iterationen in der Pfadsuche verringert.
In AbsOpt werden die Iterationen in FindAugmentablePaths gezählt. Als Instanzen
wurden vollständige gerichtete Graphen genutzt, mit Kapazitäten zufällig gleichverteilt im
Bereich von
1
bis
1000.
Gemittelt wurde über 5 Iterationen.
Beim Übergang zu kürzesten Wegen tritt eine deutliche Verbesserung ein. Für die optimierte Version des abstrakten Algorithmus wird nur eine Iteration der Schleife ausgeführt.
Wie schon bei der Laufzeit, zeigt AbstractSP hier eine groÿe Varianz.
74
4.3 Empirische Ergebnisse
FordFulkerson
EdmondsKarp
AbstractOpt
6
Zeit (s)
5
4
3
2
1
0
23
26
29
212
215
218
221
Maximale Kantenkapazität
Pfadsuchen pro Augmentierungsschritt
Abbildung 4.18: Einuss der Kantenkapazitäten auf die Laufzeit. Instanz ist ein vollständiger gerichteter Graph mit 100 Knoten.
Abstract
AbstractSP
AbstractOpt
60
50
40
30
20
10
0
39
77
116
154
193
232
270
309
347
Anzahl Knoten
Abbildung 4.19: Vergleich der Iterationen der unterschiedlichen abstrakten Algorithmen. Instanzen
sind vollständige gerichtete Graphen.
75
5 Zusammenfassung und Ausblick
In dieser Arbeit wurde ein Algorithmus um Berechnen eines maximalen Flusses entwickelt
und implementiert, der auf dem abstrakten Fluss-Algorithmus von McCormick basiert. Der
abstrakte Algorithmus hat jedoch eine sehr hohe Laufzeit, da er pfadbasiert arbeitet und
in jedem Iterationsschritt eine potenziell groÿe Menge neuer positiver Pfade hinzugefügt
werden. Die Menge der positiven Pfade bleibt zwar polynomiell, es wird jedoch zusätzlich
ein polynomielles Orakel benötigt, um neue verletzende Pfade zu berechnen.
Der Algorithmus wurde auf kantenbasierte Netzwerke übertragen. Dadurch verringert
sich der Aufwand, da keine positiven Pfade gespeichert werden müssen. Zusätzlich können
bekannte Prinzipien, wie die Breitensuche, in Graphen genutzt werden, um Pfade zu nden.
Die Laufzeit des Algorithmus ist pseudopolynomiell. Durch den zusätzlichen Aufwand
(verglichen mit Algorithmen, die Rückwärtskanten nutzen) während des Augmentierungsschrittes, ist der Algorithmus in der Laufzeit nicht mit anderen bekannten und schnellen Algorithmen vergleichbar. Durch eine sinnvolle Implementierung konnte eine Version
erstellt werden, die auf einigen Instanzen schneller arbeitet, als der normale Ford und
Fulkerson-Algorithmus.
In der Analyse in Abschnitt 4.2 haben wir einige Worst-Case-Beispiele gesehen. Sie zeigen, dass der Algorithmus pseudopolynomielle Laufzeit hat, auch wenn kürzeste Wege genutzt werden. Dies beantwortet für unsere Netzwerke die Frage, ob ein mächtigeres Orakel,
das immer kürzeste Wege zurückgibt, zu einer polynomiellen Laufzeit führt. Die Beispiele
sind jedoch komplizierter, als die von Ford und Fulkerson angegebenen Beispiele für ihren
Algorithmus. In der Praxis zeigt sich auch, dass die Anzahl der Augmentierungsschritte
zwar höher ist, als die Anzahl der Augmentierungsschritte des Algorithmus von Edmonds
und Karp, dass sie jedoch deutlich geringer ist, als die vom Algorithmus von Ford und
Fulkerson. Kantenkapazitäten haben einen deutlich geringeren Einuss auf die Laufzeit.
Wir haben in der Analyse ebenfalls gesehen, dass der Algorithmus nicht terminiert, falls
die Kapazitäten irrational sind. Die bekannten Beispiele reichen dafür jedoch nicht aus, auf
ihnen terminiert der Algorithmus immer, falls er kürzeste Wege benutzt. Auch hier müssen
die Beispiele deutlich komplizierter sein. Ein Beispiel von Zwick wurde abgewandelt, da
in diesem Beispiel alle Pfade kürzeste Wege haben. Es ist noch kein Beispiel bekannt, auf
dem der Algorithmus gegen einen nicht maximalen Wert konvergiert.
In Abschnitt 4.2 wurde ein Verfahren vorgestellt, mit dem in
Ω(n ·
√
n)
n Augmentierungsschritten
Kanten saturiert werden können. Die optimierte Version des kantenbasierten
77
5 Zusammenfassung und Ausblick
abstrakten Fluss-Algorithmus aus 4.1.2 arbeitet auf dieser Instanz um eine Gröÿenordnung
schneller, als die nicht optimierte Version.
Auÿer diesen Optimierungen wurde keine weitere Verbesserung vorgenommen. In jedem
Augmentierungsschritt werden die berechneten Mengen
Lφ , Aφ
und
Tφ
verworfen und neu
berechnet. Es wird nicht beachtet, wie sich diese Mengen ändern, wenn eine Kante saturiert
wird, oder wieder augmentierbar wird. Dadurch kann Laufzeit eingespart werden.
Weiterhin können bekannte Prinzipien anderer Flussalgorithmen übernommen werden,
um die Laufzeit zu senken. Ein Beispiel hierfür ist der Sperruss. Es ist nicht klar, ob es
sowas wie einen
abstrakten Sperruss
gibt und wie ein solcher berechnet werden könnte.
Der angegebene Algorithmus berechnet nur maximale Flüsse und nutzt das von Homan
vorgegebene Szenario der abstrakten Flüsse nur eingeschränkt. Es existiert ein Algorithmus
von Martens und McCormick, der die Möglichkeit zusätzlicher Gewichte auf den Pfaden
nutzt. Eine konkrete Implementierung dieses abstrakten Fluss-Algorithmus auf einem kantenbasierten Netzwerk steht noch aus.
78
Notationsverzeichnis
N
Die Menge
{1, 2, 3, . . .}
N0
Die Menge
N∪0
R
Die Menge der reellen Zahlen.
P(M )
Die Potenzmenge einer Menge
|M |
Anzahl der Elemente einer Menge
v∈
Rn
der natürlichen Zahlen.
der natürlichen Zahlen und die Null.
M.
M.
Ein Spaltenvektor.
Ai
Die
AT
Transponierte Matrix zu einer Matrix
f |A
Die Einschränkung einer Funktion
⊥
Uninitialisierte Variable oder Variable ohne Inhalt.
≡
Äquivalenzklasse bezüglich ganzzahliger Division mit Rest.
mod
i-te
Zeile einer Matrix
A.
A.
f :M →N
auf den Denitionsbereich
A ⊆ M.
Der Rest einer ganzzahligen Division.
79
Literaturverzeichnis
[1] Ahuja, Ravindra K., Thomas L. Magnanti und James B. Orlin:
Flows: Theory, Algorithms, and Applications.
[2] Badics, T. und E. Boros:
Network
Prentice Hall Inc., 1993.
Implementing a Maximum Flow Algorithm: Experiments
With Dynamic Trees. In: Johnson, David S. und Catherine C. McGeoch (Herausgeber): Network Flows and Matching: First DIMACS Implementation Challenge,
DIMACS Series in Discrete Mathematics and Theoretical Computer Science, 12, Seiten 4363. American Mathematical Society, Providence, RI, 1993.
[3] Cormen, Thomas K., Charles E. Leiserson, Ronald L. Rivest und Clifford
Stein:
Introduction to Algorithms.
MIT Press, 2. Auflage, 2001.
Maximization of a linear function of variables subject to linear
inequalities. In: Koopmans, Tjalling. C. (Herausgeber): Activity Analysis of Production and Allocation, Cowles Commission Monograph No. 13, Kapitel XX, Seiten
[4] Dantzig, George B.:
339347. Jon Wiley & Sons, Inc., New York, N. Y., 1951.
On the Max-Flow Min-Cut
Linear inequalities and related systems, Annals of Mathe-
[5] Dantzig, George B. und Delbert R. Fulkerson:
Theorem of Networks.
In:
matics Studies, no. 38, Seiten 215221. Princeton University Press, Princeton, N. J.,
1956.
Algorithms for Solution of a Problem of Maximum Flow in Networks
with Power Estimation. Soy. Math. Doklady, 11:1277, 1970.
[6] Dinic, Efim A.:
[7] Edmonds, Jack und Richard M. Karp:
Eciency for Network Flow Problems.
Theoretical Improvements in Algorithmic
Journal of the Association for Computing
Machinery, 19(2):248264, 1972.
[8] Elias, Peter, Amiel Feinstein und Claude E. Shannon:
Flow Through a Network.
Note on the Maximum
Institute of Radio Engineers, Transactions on Information
Theory, IT-2(December):117119, 1956.
A Simple Algorithm for Finding Maximal Network Flows and an Application to the Hitchcock Problem. Canadian
[9] Ford, Jr., Lester R. und Delbert R. Fulkerson:
Journal of Mathematics., 9:210218, 1957.
81
Literaturverzeichnis
[10] Ford, Lester R. Jr. und Delbert R. Fulkerson:
work.
Maximal Flow through a Net-
Canadian Journal of Mathematics, 8:399404, 1956.
[11] Ford, Lester R. Jr. und Delbert R. Fulkerson:
Flows in Networks.
Princeton
University Press, Princeton, NJ, 1962.
[12] Goldberg, Andrew V. und Satish Rao:
Beyond the Flow Decomposition Barrier.
Journal of the ACM, 45(5):783797, 1998.
[13] Goldberg,
Andrew
V.
Maximum-Flow Problem.
und
Robert
E.
Tarjan:
A new Approach to the
Journal of the Association for Computing Machinery,
35(4):921940, 1988.
A Computational Comparison
of the Dinic and Network Simplex Methods for Maximum Flow. Annals of Operations
[14] Goldfarb, Donald und Michael D. Grigoriadis:
Research, 13:83123, 1988.
A Fast Algorithm for the Generalized Parametric Minimum Cut Problem and Applications. Algorithmica. An International
[15] Gustfield, Dan und Charles Martel:
Journal in Computer Science, 7(5-6):499519, 1992.
A Polynomial Algorithm in Linear Programming.
[16] Ha£ijan, Leonid G.:
Akademii Nauk SSSR, 244(5):10931096, 1979.
Doklady
Englische Übersetzung: Soviet Ma-
thematics Doklady, 20:191194, 1979.
[17] Harris, T. E. und F. S. Ross:
Capacities.
Fundamentals of a Method for Evaluating Rail Net
(The RAND Corporation Research Memorandum RM-1573), California,
1955.
[18] Hassin, Refael:
Maximum ow in (s, t) planar networks.
Information Processing
Letters, 13(3):107, 1981.
[19] Henzinger, Monika R., Philip Klein, Satish Rao und Sairam Subramanian:
Faster shortest-path algorithms for planar graphs.
Journal of Computer and System
Sciences, 55(1, part 1):323, 1997. 26th Annual ACM Symposium on the Theory of
Computing (STOC '94) (Montreal, PQ, 1994).
[20] Hoffman, Alan J.:
A Generalization of Max Flow-Min Cut.
Mathematical Pro-
gramming, 6:352359, 1974.
[21] Johnson, David S. und Catherine C. McGeoch (Herausgeber):
and Matching: First DIMACS Implementation Challenge.
Network Flows
DIMACS Series in Discrete
Mathematics and Theoretical Computer Science, 12. American Mathematical Society,
Providence, RI, 1993.
Papers related to the 1st DIMACS Challenge on Flows and
Matching held at DIMACS October 1416, 1991.
82
Literaturverzeichnis
[22] Karmarkar, Narendra B.:
A New Polynomial-Time Algorithm for Linear Pro-
gramming. Combinatorica. An International Journal of the János Bolyai Mathematical
Society, 4(4):373395, 1984.
[23] King, Valerie, Satish Rao und Robert E. Tarjan:
ximum Flow Algorithm.
A Faster Deterministic Ma-
Journal of Algorithms, 17(3):447474, 1994. Third Annual
ACM-SIAM Symposium on Discrete Algorithms (Orlando, FL, 1992).
[24] Korthe, Bernhard und Jens Vygen:
Combinatorial Optimization.
Springer-
Verlag, Berlin Heidelberg, 2008.
[25] Malhotra, Vishv M., M. Pramodh Kumar und Shachindra. N. Maheshwari:
An O(V 3 ) Algorithm for Finding Maximum Flows in Networks.
Information Proces-
sing Letters, 7(6):277278, 1978.
[26] Martens, Maren und S. Thomas McCormick:
Weighted Abstract Flow.
In:
[27] McCormick, S. Thomas:
A Polynomial Algorithm for
IPCO, Seiten 97111, 2008.
A Polynomial Algorithm for Abstract Maximum Flow.
UBC Faculty of commerce Working Paper 95-MSC-001, 1998.
[28] Mehrotra, Sanjay:
thod.
On the Implementation of a Primal-Dual Interior Point Me-
SIAM Journal on Optimization, 2(4):575601, 1992.
[29] Monge, Gaspard:
Mémoire sur la théorie des déblais et de remblais.
Histoire de
l'Académie Royale des Sciences, Année M. DCCLXXXI, avec les Mémoires de Mathématique et de Physique, pour la même année, Paris, 1781.
[30] Schrijver,
Alexander:
Theory of Linear and Integer Programming.
Wiley-
Interscience Series in Discrete Mathematics and Optimization. John Wiley & Sons
Ltd., Chichester, 1986. A Wiley-Interscience Publication.
[31] Schrijver, Alexander:
Flows in Railway Optimization.
Nieuw Archief voor Wis-
kunde. Vijfde Serie, 9(2):126131, 2008.
An Introduction to Network Flows over Time. In: Cook, William J., László Lovász und Jens Vygen (Herausgeber): Research Trends in Combinatorial Optimization, Seiten 451482. Springer, 2009.
[32] Skutella, Martin:
[33] Sleator, Daniel D. und Robert E. Tarjan:
A data structure for dynamic trees.
Journal of Computer and System Sciences, 26(3):362391, 1983.
[34] Wegener, Ingo:
Komplexitätstheorie. Grenzen der Ezienz von Algorithmen. Sprin-
ger, Berlin Heidelberg New-York, 2003.
83
Literaturverzeichnis
The smallest networks on which the Ford-Fulkerson maximum ow procedure may fail to terminate. Theoretical Computer Science, 148, 1995.
[35] Zwick, Uri:
84
Sachverzeichnis
Augmentieren, 9
Orakel, 29
dual zulässige Lösung,
siehe
duales Pro-
Pfad, 9, 16
augmentierend, 9
gramm
negativ, 50
duales Programm, 6
Endknoten,
siehe
positiv, 50
Pfad
Startknoten, 9
verletzend, 34
Fluss-Dekomposition, 11
Pfad-Dekomposition, 12
Graph, 7
abstrakter, 16
Kante, 7
ausgehende, 7
eingehende, 7
links, 9
rechts, 9
Quelle, 7
Rückwärtskante, 22
rechts, 16
Residualnetzwerk, 22
Restkapazität, 22
RMFGEN, 69
Kapazität, 7, 17
Schnitt, 13
Kn ,
Senke, 7
68
Knoten, 7
Startknoten,
siehe
Pfad
Kreis, 9
Kreuzungsmenge, 16
lineares Programm, 5
links, 16
Mehrfachkante, 7
Multigraph, 7
trennende Menge, 13
v+,
7
v−, 7
Washington-Mesh, 69
Weg, 9
zulässige Lösung,
Netzwerk, 7
siehe lineares Programm
Netzwerkuss, 8
abstrakter, 17
85
Hiermit versichere ich, dass ich die vorliegende Arbeit selbstständig verfasst habe und
keine anderen als die angegebenen Quellen und Hilfsmittel verwendet sowie Zitate kenntlich gemacht habe.
Herten, den 20. 07. 2009
Jan-Philipp Kappmeier