Diplomarbeit - Muhammed Ali Alat

Diplomarbeit
Schwerpunkt
Kombinatorische Optimierung
Zum Thema
Praktische Lösung von Minimum Cost Flow Problemen:
Ein Vergleich verschiedener Algorithmen
Autor:
Muhammed Ali Alat
bei
Institut für Mathematik
Technische Universität Berlin
Berlin, 4. August 2011
Inhaltsverzeichnis
1 Einleitung
1
1.1
Zusammenfassung und Ziele der Arbeit
. . . . . . . . . . . . . . . . . . . .
1
1.2
Historische Entwicklung . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2
2 Grundlagen
4
2.1
Definitionen und Notation . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.2
Das Minimum Cost Flow Problem . . . . . . . . . . . . . . . . . . . . . . . 12
2.3
Residualgraphen und -netzwerke . . . . . . . . . . . . . . . . . . . . . . . . 14
2.4
Annahmen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.5
Netzwerkflussprobleme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.6
Optimalitätsbedingungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
2.7
4
2.6.1
Negative Kreise . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
2.6.2
Reduzierte Kosten . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
2.6.3
Komplementärer Schlupf . . . . . . . . . . . . . . . . . . . . . . . . . 26
Dateiformate . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
3 Der Netzwerk Simplex Algorithmus
29
3.1
Definitionen und Sätze . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
3.2
Ausgangslösung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
3.3
Der Algorithmus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
3.4
Terminierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
3.5
Laufzeit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
4 Der Cost Scaling Algorithmus
56
4.1
Definitionen und Sätze . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
4.2
Der Algorithmus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
4.3
Verbesserungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
4.4
4.3.1
Globale Aktualisierung des Potentials . . . . . . . . . . . . . . . . . 70
4.3.2
Verfeinerung des Potentials . . . . . . . . . . . . . . . . . . . . . . . 72
4.3.3
Kanten auslassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
4.3.4
Push Operationen eliminieren . . . . . . . . . . . . . . . . . . . . . . 73
Laufzeit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
i
Inhaltsverzeichnis
5 Vergleich verschiedener Algorithmen
75
5.1
Algorithmen und Programme . . . . . . . . . . . . . . . . . . . . . . . . . . 75
5.2
Problemklassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
5.2.1
Grid-On-Torus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
5.2.2
GRIDGRAPH . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
5.2.3
NETGEN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
5.2.4
TCHAIN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
5.3
Auswertung der Instanzen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
5.4
Analyse des Auswertung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
Anhang
A
Liste der Abbildungen
C
Liste der Algorithmen
E
Literaturverzeichnis
F
ii
1 Einleitung
Das Minimum Cost Flow Problem beschreibt ein Transportproblem, bei dem die Transportkosten minimiert werden müssen. Die Problemstellung wird durch Standorte beschrieben, in denen ein Angebot oder eine Nachfrage existiert. Mit einem Transportplan muss
die Nachfrage dabei befriedigt werden. Um den Transport ausführen zu können, muss das
Angebot über günstige Wege zur Nachfrage befördert werden. Der Transport der Ware ist
nämlich keineswegs umsonst und verursacht Kosten. Wir betrachten das Problem ganzheitlich und versuchen die gesamte Nachfrage mit dem gesamten Angebot zu decken und
gleichzeitig die Transportkosten auf ein Minimum zu senken. Ein weiteres Detail, dass
mit dem Minimum Cost Flow Problem modelliert wird, ist die begrenzte Kapazität der
Beförderung. Wurde nämlich eine günstige Strecken gefunden, kann es trotzdem sein, dass
nur eine relativ kleine Menge auf diesem Weg transportiert werden kann. Um die Nachfrage trotzdem vollständig zu befriedigen, muss in diesen Fällen nach weiteren eventuell
teureren Wegen gesucht werden, damit ein Konsument die nachgefragte Menge vollständig
erhält.
Mann kann sich als Beispiel vorstellen, dass ein Unternehmen für ein bestimmten Rohstoff in den 16 Bundeshauptstädten Deutschlands ein Lager besitzt. Die Vorräte der 16 Lager sind begrenzt und können durchaus unterschiedlich groß sein, decken aber die gesamte
Nachfrage Deutschlands ab. Als Abnehmer können alle Städte in Deutschland betrachtet
werden. Wenn die Nachfrage der Abnehmer im Verhältnis zur Einwohnerzahl der Stadt
steht, ergeben sich ganz unterschiedliche Bedürfnisse. Die Entfernungen zu den Städten
können in diesem Beispiel als die Kosten angenommen werden. Je weiter der Rohstoff
transportiert wird, desto höhere Kosten entstehen. Es ist dabei auch möglich, dass eine
Bundeshauptstadt Städte aus anderen Bundesländern beliefert, weil diese zum Beispiel
näher liegen und somit geringere Transportkosten verursachen. Weiterhin wird angenommen, dass die Kapazitäten der Straßen begrenzt sind und unterschiedlich groß sein können
oder dass auf einer Straße nur begrenzte Transportmittel zur Verfügung stehen. Dadurch
lässt sich keine beliebige Menge zwischen zwei Orten befördern. Das Minimum Cost Flow
Problem sucht nun nach einem kostengünstigsten Transportplan, um in diesem Fall alle
Abnehmer mit dem Rohstoff zu versorgen und die Bedürfnisse vollständig zu decken.
1.1 Zusammenfassung und Ziele der Arbeit
Um das Minimum Cost Flow Problem zu modellieren werden wir in Kapitel 2 alle notwendigen Definitionen anhand eines Beispiels einführen. Das Beispiel wird uns durchgehend
1
1 Einleitung
begleiten und unterschiedliche Betrachtungen der Problemstellung aufzeigen. Mit einigen
interessanten Beobachtungen und Annahmen wird anschaulich illustriert, unter welchen
Bedingungen das Minimum Cost Flow Problem optimal lösbar ist. In den folgenden Kapiteln werden wir zwei Algorithmen, den Netzwerk-Simplex-Algorithmus und Cost Scaling
Algorithmus, vorstellen. Dabei untersuchen wir, welche Techniken zum Einsatz kommen
und welche Bedingungen zum Finden einer optimalen Lösung in Anspruch genommen
werden. Im Folgenden werden mit vier bekannten Programmen 65 Probleme verschiedener Problemklassen gelöst. Die Ergebnisse mit Laufzeiten von weniger als einer Sekunde
bis zu fast drei Tagen werden uns Aufschluss darüber geben, welches Programm für den
praktischen Einsatz am besten geeignet ist und wo die Vor- und Nachteile der einzelnen
Programme liegen.
1.2 Historische Entwicklung
Alexander Schrijver hat im Jahre 2002 eine Arbeit über die historische Entwicklung
von Transportproblemen[Sch02] veröffentlicht. Auf mathematischer Basis untersuchte laut
Schrijver als einer der ersten der russische Schriftsteller Tolstoi dieses Transportproblem.
Tolstoi hat sich in einer Studie von 1930[Tol30] mit Methoden zum Lösen von Transportproblemen mit minimalen Kosten auseinandergesetzt und war sich bewusst, dass eine
Lösung keine negativen Zyklen beinhalten darf.
Die mathematische Modellierung und Lösung von Transportproblemen als lineares Programm geht auf den russischen Mathematiker Kantorovich zurück. In seiner Veröffentlichung an der staatlichen Universität Leningrad von 1939[Kan39] betrachtet er dabei unter
anderem das Problem der Verteilung von Arbeitskräften an verschiedene Maschinen und
die Optimierung von Frachtsendungen. Er gibt teilweise unvollständige mathematische
Methoden zur Lösung der Probleme vor. Im Jahre 1942[Kan06] und in der gemeinsamen
Ausarbeitung mit Gavurin im Jahre 1949[MG49] vertieft er das Transportproblem.
Unabhängig von Kantorovich und Gavurin erforschten in der USA ungefähr zur selben
Zeit auch Hitchcock und Koopmanns Transportprobleme. 1941 beschreibt Hitchcock detailliert Transportprobleme[Hit41] und das erste MCFP auf bipartiten Graphen. Bei seinen
Lösungsansätzen verwendet Hitchcock Matrizen zur Beschreibung des Transportproblems
und zeigt, dass die Lösung in der konvexen Hülle dieser Matrix liegen muss.
Eines der Algorithmen zum Lösen von linearen Programmen und damit auch vom Minimum Cost Flow Problem ist der Simplex Algorithmus. Er wurde im Jahre 1953 von
Dantzig entwickelt [GNS08, Seite 171] und hat sich für den Einsatz in der Praxis bewährt
[Gol94]. Der Simplex Algorithmus und dessen Abwandlungen werden immer noch von
einer Vielzahl von Softwareunternehmen, wie auch von IBM [IBM09], eingesetzt.
Ein weiterer effizienter Algorithmus zum Lösen von Minimum Cost Flow Problemen
2
1.2 Historische Entwicklung
ist der Cost Scaling Algorithmus von Goldberg [GK93]. Er beruht auf dem Push Relabel Algorithmus von Goldberg und Tarjan aus dem Jahre 1988 [KV08] und wird vom
Unternehmen IG Systems1 weiterentwickelt.
1
http://www.igsystems.com
3
2 Grundlagen
Das Minimum Cost Flow Problem hat seine Wurzeln sowohl in der Graphentheorie als
auch in der kombinatorischen und linearen Optimierung. Dieser Abschnitt wird die zur
Modellierung notwendigen Begriffe und Definitionen für das Minimum Cost Flow Problem
einführen. Da das Problem als Graph modelliert wird, werden einige Begriffe aus der
Graphentheorie vorgestellt. Weiterhin werden auch einige Annahmen eingeführt, welche
später in den Algorithmen genutzt werden. Bei der Notation orientieren wir uns weitgehend
am Buch Network Flows von Ahuja et al. [AMO93].
2.1 Definitionen und Notation
Definition 1 (Graph). Ein Graph G = (V, E) ist definiert durch die Knotenmenge V und
Kantenmenge E. Mit n = |V | wird die Anzahl der Knoten und mit m = |E| die Anzahl
der Kanten angegeben. Jede Kante eij ∈ E verbindet zwei Knoten i und j aus V . Wir
sagen dann, dass i und j inzident zu eij sind oder dass i und j adjazent sind [Jun04, Seite
2]. Für einen Graphen G bezeichnet weiterhin V (G) = V die Menge der Knoten von G
und E(G) = E die Menge der Kanten von G [KV08, Seite 15].
Definition 2 (Gerichtete und ungerichtete Graphen). Ein gerichteter Graph unterscheidet
sich von einem ungerichteten Graphen darin, dass die Kanten von einem Startknoten zu
einem Zielknoten führen. Es gilt eij = (i, j) ∈ E, wenn die Kante eij in einem gerichteten
Graphen von i nach j führt. Bei einem ungerichteten Graphen führt jede Kante in beide
Richtungen [AMO93, Seite 25]. Eine weitere Bezeichnung des gerichteten Graphen lautet
Digraph, was für eine Abkürzung der englischen Übersetzung directed Graph steht.
Wir werden im folgenden die Bezeichnungen V und E immer in Zusammenhang mit
dem Graphen G benutzen. Wenn von der Knotenmenge V oder der Kantenmenge E die
Rede ist, wird implizit der Graph G = (V, E) vorausgesetzt. Bevor wir einen Graphen
abbilden, gehen wir zunächst auf die Notation eines Graphen ein.
i
eij
j
Abbildung 2.1: Notation
In der Notation zeichnen wir zwei Knoten und verbinden diese mit einer Kante. So
steht im Knoten der Name des Knoten i aus V und auf der Kante entsprechend der Name
der Kante eij aus E. Es kann durchaus vorkommen, dass wir auch weitere Werte an den
4
2.1 Definitionen und Notation
Knoten und Kanten wiedergeben. Ist das der Fall, wird neben dem Graphen auch eine
entsprechende Notation wie in der Abbildung 2.1 wiedergegeben.
Als nächstes betrachten wir einen ungerichteten und gerichteten Graphen.
2
e12
2
e24
e23
1
e13
e12
4
e24
e23
1
e34
e13
4
e34
3
3
Abbildung 2.2: Ungerichteter Graph
Abbildung 2.3: Digraph
In der Abbildung 2.2 ist ein ungerichteter Graph G mit vier Knoten und fünf Kanten
zu sehen. Es gilt:
G = (V, E)
V = {1, 2, 3, 4}
n=4
E = {e12 , e13 , e23 , e24 , e34 }
m=5
Die Knotenmenge V und Kantenmenge E beschreiben den Graphen ausführlich. Dabei ist
jede Kante eij durch zwei Knoten beschrieben, die es verbindet. Die Abbildung 2.3 zeigt
den Digraphen G mit gerichteten Kanten.
Definition 3 (Adjazenzmatrix). Eine n × n-Adjazenzmatrix A bildet den Graphen G als
Matrix ab. Die Zeilen und Spalten der Matrix repräsentieren die Knoten und die Einträge
geben darüber Auskunft, ob eine Kante zwischen zwei Knoten existiert oder nicht. Die
Adjazenzmatrix A besteht nur aus den Einträgen 0 oder 1:

1
aij =
0
wenn eij ∈ V ,
sonst
[Jun04, Seite 38].
Definition 4 (Inzidenzmatrix). Eine Inzidenzmatrix A dient der Abbildung eines Digraphen G in Form einer Matrix. Dabei ist A eine n × m-Matrix, bei dem die Zeilen die
Knoten und die Spalten die Kanten darstellen. Die Matrix A hat folgende Einträge:



1


aij = −1



0
wenn i Startknoten von eij ,
wenn i Zielknoten von eji ,
sonst.
In jeder Spalte der Inzidenzmatrix A gibt es somit genau einen Eintrag mit 1 und −1 und
alle restlichen Einträge sind 0. Mit dem Eintrag 1 wird dabei jeder Kante in einer Spalte
der Startknoten und mit −1 der Zielknoten zugeordnet [Jun04, Seite 37].
5
2 Grundlagen
Der Digraph G aus der Abbildung 2.3 besitzt folgende Adjazenzmatrix Aa und Inzidenzmatrix Ai :
e12

0

0
Aa = 
0

0
1 1
0 1
0 0
0 0

0

1

1

0

e13
e23
e24
e34
1
0
0
0
0
1
1
−1
−1
0
0
0
−1
1

 −1
Ai = 
0

0


0 

1 

−1
Definition 5 (Wege, Pfade und Kreise). Ein Weg W ist eine Abfolge von Knoten und
Kanten, bei der jede Kante seine benachbarten Knoten verbindet und nur einmal vorkommt. Ein Pfad ist ein Weg mit der zusätzlichen Eigenschaft, dass jeder Knoten im Pfad
nur einmal besucht wird. Ein Weg oder Pfad kann auch als ein s-t-Weg oder s-t-Pfad
bezeichnet werden, wenn er im Knoten s ∈ V beginnt und im Knoten t ∈ V endet [KV08,
Seite 19]. Ein Kreis ist ein Pfad aus mindestens drei Knoten, in der jeder Knoten bis
auf den ersten und letzten unterschiedlich sind [Jun04, Seite 5]. Ein Kreis besteht aus
mindestens zwei Kanten und zwei unterschiedlichen Knoten. Ein Weg, Pfad oder Kreis
ist gerichtet, wenn jede Kante als Startknoten seinen Vorgängerknoten und als Zielknoten
seinen Nachfolgeknoten hat und ansonsten ungerichtet.
Betrachten wir die Mengen
W = (2, e23 , 3, e13 , 1, e12 , 2, e24 , 4),
WE = (e23 , e13 , e12 , e24 ),
P = (1, e12 , 2, e24 , 4) und
K = (1, e12 , 2, e23 , 3, e13 , 1)
aus der Abbildung 2.3 so ist W ein ungerichteter Weg, aber kein Pfad und Kreis. P ist
hingegen ein gerichteter Pfad und somit auch ein Weg. Schließlich ist K ein ungerichteter
Kreis und Weg. Soweit es ersichtlich ist, können Wege, Pfade und Kreise auch als Abfolge
von nur Knoten oder Kanten notiert werden [Jun04, Seite 5]. Demnach ist zum Beispiel
W mit WE eindeutig über die Kanten identifizierbar.
Definition 6 (Zusammenhängender Graph). Ein Graph G = (V, E) heißt zusammenhängend, wenn zu je zwei beliebigen paarweise verschiedenen Knoten in V ein ungerichteter
Weg existiert [KV08, Seite 19].
Definition 7 (Subgraph). Ein Graph Gs ist ein Subgraph von einem Graphen G = (V, E),
wenn Gs aus Knoten und Kanten von G besteht. Ist Vs ⊆ V und Es ⊆ E, so ist Gs =
(Vs , Es ) ein Subgraph. Wir sprechen von einem induzierten Subgraphen Gs , wenn Vs ⊆ V
gilt und Es aus allen Kanten eij ∈ E mit i ∈ Vs und j ∈ Vs besteht. In einem induzierten
Subgraphen werden demnach Knoten aus V gewählt und alle verfügbaren Kanten aus E
6
2.1 Definitionen und Notation
hinzugefügt. Besteht hingegen Gs = (V, Es ) aus allen Knoten in G und ist Es ⊆ E, so
heißt Gs spannender Subgraph [Jun04, Seite 3].
Definition 8 (Baum). Ein Baum T = (V, E) ist ein zusammenhängender Graph mit
m=n−1
Kanten. Insbesondere existieren in einem Baum keine Kreise [Jun04, Seite 8]. Ist T zusätzlich ein spannender Subgraph eines Graphen G, so nennen wir T einen spannenden Baum
von G [Jun04, Seite 65].
Definition 9 (Kantenmenge und Grad eines Knotens). Alle Kanten die zu einem Knoten i
inzident sind, werden in der Menge δ(i) zusammengefasst. Betrachten wir nur die Kanten
mit dem Startknoten i, schreiben wir δ + (i). Entsprechend schreiben wir δ − (i) für alle
Kanten, die i als Zielknoten haben. Die Anzahl der Kanten, die mit einem Knoten i
verbunden sind, heißt Grad eines Knotens und wird mit |δ(i)| dargestellt. Mit |δ − (i)|
bezeichnen wir die Anzahl der eingehenden und mit |δ + (i)| die Anzahl der ausgehenden
Kanten in den Knoten i. |δ + (i)| wird Ausgangsgrad und |δ − (i)| Eingangsgrad von i genannt
[KV08, Seite 17].
So hat zum Beispiel in Abbildung 2.3 der Knoten 2 den Eingangsgrad 1, Ausgangsgrad
2 und den Grad 3.
Definition 10 (Dichte eines Graphen). Als Dichte bezeichnen wir eine Zahl, die das
Verhältnis der Anzahl der Kanten zur Anzahl der Knoten wiedergibt. Die Dichte d entspricht dem Wert
m
n.
Ist d die Dichte eines Graphen, so existieren im Graphen n Knoten
und d · n Kanten [BJG10, Seite 331].
Definition 11 (Blatt). Ist T = (V, E) ein Baum, so heißt ein Knoten i ∈ V mit |δ(i)| = 1
Blatt. Blätter besitzen demnach nur eine Kante, die sie mit dem restlichen Baum verbindet
[KV08, Seite 19].
Bisher haben wir einen Graphen über die Menge V aus Knoten und E aus Kanten beschrieben. Im folgenden werden wir einem Graphen noch weitere Informationen bezüglich
seiner Kanten und Knoten hinzufügen. Bernhard Korte und Jens Vygen erweitern den
Graphen mit zusätzlichen Informationen zum Netzwerk [KV08, Seite 183]. Im Buch von
Ahuja et al. werden die Begriffe Graph und Netzwerk hingegen synonym benutzt [AMO93,
Seite 25]. Zusätzliche Informationen werden in ihrem Buch Network Flows [AMO93] einem
Graphen oder Netzwerk einfach zugeordnet. Wir werden ein Graphen G, dem weitere Informationen zugeordnet werden, Netzwerk nennen, um genauer differenzieren zu können.
So enthält ein Netzwerk neben einem Graphen noch weitere Daten bezüglich seiner Kanten
oder Knoten.
Definition 12 (Balance). Im Minimum Cost Flow Problem gibt es drei Arten von Knoten. Diese sind Knoten, die über ein Angebot oder über eine Nachfrage verfügen und
7
2 Grundlagen
Durchflussknoten. Mit der Balance geben wir für jeden Knoten die Menge an, die angeboten oder nachgefragt wird. Ein Durchflussknoten hat dabei eine Balance von 0, da es
weder Einheiten anbietet noch nachfragt. Die Balancen geben wir für einen Knoten i mit
bi an. Ist die Balance bi vom Knoten i positiv, so handelt es sich um eine Quelle mit dem
Angebot bi . Ist die Balance bi negativ, haben wir es mit einer Senke zu tun, die die Menge
−bi nachfragt [AMO93, Seite 5].
Nachdem die Balancen der einzelnen Knoten bekannt sind, muss versucht werden das
Angebot zur Nachfrage zu transportieren. Dieser Transport, den wir später auch Fluss nennen werden, findet auf den Kanten statt. Da wir bei einem Minimum Cost Flow Problem
einen Digraphen betrachten, können die Einheiten auf einer Kante nur in einer Richtung
transportiert werden. Bevor wir uns weiteren Details über die Kanten widmen, schauen
wir uns erst mal das aus Abbildung 2.3 bekannte Beispiel mit Balancen an:
bi
0
i
2
6
e12
e24
e23
1
e13
−4
4
eij
e34
3
j
−2
bj
Abbildung 2.4: Netzwerk mit Balancen
Das Netzwerk N = (G, b) besteht aus dem Graphen G und den zusätzlichen Balancen b.
Die Balancen bi geben für jeden Knoten i aus V die Werte des Angebots beziehungsweise
der Nachfrage an. In der Abbildung 2.4 haben die Knoten die Balancen
b1 = 6, b2 = 0, b3 = −2 und b4 = −4.
Beim Knoten b1 handelt es sich um eine Quelle, die über ein Angebot von 6 verfügt.
Die Knoten b3 und b4 fragen eine Menge von 2 und 4 Einheiten nach und bilden somit
zwei Senken. Beim Knoten b2 handelt es sich um einen Durchflussknoten. Die gerichteten
Kanten geben an, in welche Richtungen Mengen transportiert werden dürfen.
Bei der Bezeichnung der Balance b ohne Index handelt es sich um einen Vektor, wobei
in unserem Fall
b> = (6, 0, −2, −4)
ist. Schreiben wir an die Balance einen Index i wie bei bi , so betrachten wir nur die Balance
eines einzelnen Knotens i. Der Vektor b befindet sich im Raum Rn , da für jeden Knoten
eine Balance angegeben werden muss.
Zur einfachen Visualisierung werden wir in Abbildungen für einen Knoten i mit der
Balance bi gleich 0 auf eine Beschriftung am Knoten ganz verzichten.
8
2.1 Definitionen und Notation
Definition 13 (Kapazitäten und Schranken). Jede Kante eij in E besitzt im Minimum
Cost Flow Problem Informationen über ihre Kapazitäten, die angeben wie viele Mengeneinheiten auf ihr maximal transportiert werden dürfen. Die Kapazität für eine Kante wird
mit uij bezeichnet und kann auch als obere Schranke verstanden werden, da sie im Englischen upper bound genannt werden. Eine Kante kann dabei keine negative Kapazität
besitzen, da entweder Güter auf dieser Kante transportiert werden können oder nicht.
Weiterhin besitzen die Kanten auch eine untere Schranke. Im Englischen lower bound genannt, werden sie mit `ij bezeichnet und geben an, wie viele Mengeneinheiten auf dieser
Kante transportiert werden müssen [AMO93, Seite 5]. Die größte Kapazität im Graphen
bezeichnen wir mit umax und es gilt
umax = max(uij : eij ∈ E)
[BJG10, Seite 164].
bi
0
i
2
6
4
1
2
3
4
−4
4
uij
4
3
j
−2
bj
Abbildung 2.5: Netzwerk mit Balancen und Kapazitäten
Das Netzwerk N aus Abbildung Abbildung 2.5 enthält nun neben den Balancen weitere
Informationen über die Kapazitäten jeder Kanten. In Abbildungen notieren wir dabei
auf der Kante nur den Wert der oberen Schranke, da wir für das erste keine unteren
Schranken voraussetzen. Wie wie später sehen werden, stellt diese Voraussetzung keine
Beeinträchtigung der Problemstellung dar (Annahme 5). Mit den Kapazitäten der Kanten
erschwert sich das Problem in dem Sinne, dass auf einem gefundenen gerichteten Weg
zwischen zwei Knoten nicht beliebig viele Mengeneinheiten transportiert werden dürfen.
Dadurch wird es unter Umständen notwendig sein, nach weiteren Wegen zu suchen.
Wie bei der Balance handelt es sich auch bei der Kapazität u um einen Vektor. Da für
alle m Kanten eine Kapazität existiert, befindet sich der Vektor u im Raum Rm
+ . Weil die
Kanten nicht wie die Knoten durchnummeriert sind, wird der Vektor u nach den Indizes
der Kanten lexikographisch sortiert. In unserem Beispiel ist
u> = (u12 , u13 , u23 , u24 , u34 ) = (4, 4, 3, 2, 4).
Definition 14 (Kosten). Wie die Kapazitäten sind beinhalten auch die Kosten Informationen für Kanten. Die Kosten werden mit cij dargestellt und beschreiben, wie viel für den
9
2 Grundlagen
Transport einer Mengeneinheit auf dieser Kante zu bezahlen ist [BJG10, Seite 127]. Mit
cmax beschreiben wir die Kosten der teuersten Kante, es gilt
cmax = max(cij : eij ∈ E)
[BJG10, Seite 164].
Durch die Einführung von Kosten werden wir später in der Lage sein Lösungen zu
bewerten. Während es darum geht, die Nachfrage mit dem Angebot zu befriedigen, sind
wir nun fähig, zwischen günstigen und teuren Lösungen zu differenzieren.
bi
0
i
2
6
(4; 3)
(2; 3)
−4
(3; 2)
1
(4; 2)
4
(uij ; cij )
(4; 3)
3
j
−2
bj
Abbildung 2.6: Netzwerk mit Balancen, Kapazitäten und Kosten
Das Netzwerk haben wir mit den Kosten endgültig erweitert, um alle Informationen, die
wir für das Problem benötigen, abzubilden. Zur Lösung des Problems brauchen wir nun
einen Transportplan, der bestimmt wie das Angebot zur Nachfrage gelangt. Um genau das
zu beschreiben, werden wir Flüsse einführen.
Definition 15 (Fluss). Ein Fluss ist eine Funktion
f : E → R+
0,
die jeder Kante vorgibt, wie viele Mengeneinheiten auf ihr transportiert werden. Wir
schreiben statt f (eij ) auch xij für den Fluss auf einer Kante eij . Der Wert xij beschreibt
die Transportmenge auf dieser Kante [Jun04, Seite 147] [AMO93, Seite 5].
Damit ein Fluss unser Problem löst, muss es zwei weitere Bedingung erfüllen, die wir
im folgenden einführen.
Definition 16 (Kapazitätseinhaltung). Die Kapazitätseinhaltung gilt für einen Fluss x,
wenn auf jeder Kante eij mindestens `ij und maximal uij Mengeneinheiten transportiert
werden. Damit wird modelliert, dass die Kapazitätsschranken auf den Kanten eingehalten
werden. Für einen Fluss x, der die Kapazitätseinhaltung erfüllt, gilt für jeden Eintrag die
Ungleichung
`ij ≤ xij ≤ uij
[AMO93, Seite 5].
10
2.1 Definitionen und Notation
Definition 17 (Flusserhaltung). Mit der Flusserhaltung wird für einen Fluss x gefordert,
dass sich die einfließenden und ausfließenden Einheiten an einem Knoten nur um die Anzahl
der Balance unterscheiden dürfen. Die Flusserhaltung gilt für einen Fluss x, wenn folgende
Gleichung erfüllt ist
X
eij
∈δ + (i)
X
xij −
eji
xji = bi
∈δ − (i)
[Jun04, Seite 147] [AMO93, Seite 5].
Mit der Flusserhaltung wird simuliert, dass keine Einheiten verloren gehen oder dazukommen.
Definition 18 (b-Fluss). Ein b-Fluss x ist ein Fluss, der zusätzlich die Eigenschaften
besitzt, dass die Kapazitätseinhaltung und Flusserhaltung gilt [KV08, Seite 219].
Mit dem b-Fluss haben wir einen Fluss, der die Bedingungen für eine Lösung unseres
Problems erfüllt. Um Flüsse miteinander vergleichen zu können, werden wir als Kriterium
die Gesamtkosten einführen.
Definition 19 (Gesamtkosten eines Flusses). Für ein gegebenen Fluss x bestimmt die
Funktion
c(x) = c> x =
X
cij · xij
eij ∈E
die Gesamtkosten für den Transport des Flusses [BJG10, Seite 129].
Für die Gesamtkosten eines Flusses und den Preis zum Transport einer Einheit auf
einer Kante wird jeweils die gängige Bezeichnung c benutzt. Zu beachten ist dabei, dass
der Preis auf einer Kante eij mit cij und der Kostenvektor einfach mit c bezeichnet wird.
Die Funktion für die Gesamtkosten eines Flusses hat immer x als Eingabevariable und
wird mit c(x) bezeichnet.
Weiterhin können wir auf die gleiche Art und Weise auch die Gesamtkosten eines Weges,
Pfades oder Kreises berechnen. Dabei werden die Kosten der Kanten einfach summiert,
da kein Fluss betrachtet wird [BJG10, Seite 88 und 162]. Betrachten wir in der Abbildung
2.6 ein Pfad P , so gilt für die Gesamtkosten folgendes:
P = (e12 , e24 )
c(P ) = c12 + c24 = 3 + 3 = 6
Die Kosten des Pfades können auch als die Kosten des Flusses interpretiert werden, der
eine Einheit über die Kanten des Pfades schickt [BJG10, Seite 160].
11
2 Grundlagen
2.2 Das Minimum Cost Flow Problem
Das Minimum Cost Flow Problem wird als lineares Programm formuliert. Folgend erfolgt die Erläuterung zum linearen Programm, so dass die Grundlage zur Bearbeitung der
anschließenden Problemstellung gegeben ist.
Definition 20 (Lineares Programm). Beschreibt c(x) eine Zielfunktion, die unter Einhaltungen linearer Nebenbedingungen minimiert oder maximiert werden muss, so handelt es
sich um ein lineares Programm oder kurz LP. Ein lineare Programm hat die Form
x ∈ Rm
min oder maxc(x)
unter den Nebenbedingungena> x = b
a ∈ Rm , b ∈ R
...
...
`i ≤ xi ≤ ui
`, u ∈ Rn und i = 1, . . . , m
[GNS08, Seite 5]. Statt unter den Nebenbedingungen schreiben wir kurz u.d.N. . Es können
dabei beliebig viele lineare Nebenbedingungen existieren. Hat das lineare Programm die
Form
u.d.N.
min oder max c(x) = c> x
c, x ∈ Rm
Ax = b
A ∈ Rn×m und b ∈ Rn
0 ≤ xi ≤ ui
u ∈ Rn und i = 1, . . . , m ,
so sprechen wir von einem LP in Standardform. Die Zielfunktion ist eine lineare Vektormultiplikation. Die Einträge in x haben eine obere Schranke u und sind positiv. Weiterhin
gibt es m Nebenbedingungen, die durch die Matrix A und den Vektor b abgebildet werden
[GNS08, Seite 100].
Eine Lösung für das Minimum Cost Flow Problem ist ein b-Fluss, der in einem Netzwerk
jeder Kante die Menge der zu transportierenden Einheiten zuordnet. Dabei muss für die
Balancen weiterhin
X
b(i) = 0
i∈V
gelten [Jun04, Seite 322], womit sichergestellt wird, dass das Angebot und die Nachfrage
übereinstimmen.
Definition 21 (Minimum Cost Flow Problem). Das Minimum Cost Flow Problem besteht
aus einem Netzwerk
N = (G, b, `, u, c).
12
2.2 Das Minimum Cost Flow Problem
Gesucht ist ein b-Fluss x für die Zielfunktion:
min c(x) =
X
xij · cij
eij ∈E
X
u.d.N.
eij
X
xij −
∈δ + (i)
xji = bi
(Flusserhaltung)
`ij ≤ xij ≤ uij
(Kapazitätseinhaltung)
eji
∈δ − (i)
[AMO93, Seite 38]. Ist A die Inzidenzmatrix zum Graphen G, so lautet die Formulierung
des linearen Programms
min c(x) = c> x
u.d.N.
Ax = b
(Flusserhaltung)
`ij ≤ xij ≤ uij
(Kapazitätseinhaltung)
[GNS08, Seite 271].
Sind für eine Lösung x die Gesamtkosten c(x) unter allen zulässigen Lösungen minimal,
sprechen wir von einer optimalen Lösung.
Schauen wir uns erneut das Beispiel aus Abbildung 2.6 an, so können wir das Netzwerk
als lineares Programm formulieren.
min c(x) = c> x = 3x12 + 2x13 + 2x23 + 3x24 + 3x34



 x12


1
1
0
0
0 
6


  x13  

−1 0

  0 
1
1
0






u.d.N. 
  x23  =  −2 
0
−1
−1
0
1
 



 x24 
0
1
0 −1 −1
−4
x34
0 ≤ xij ≤ uij ∀ eij ∈ E
Unser Ausgangsproblem ist nochmal links in der Abbildung 2.7 abgebildet. Wir werden
jetzt eine Lösung für das vorliegende Problem angeben ohne auf weitere Details einzugehen.
Der Graph rechts gibt an, wie unsere Lösung aussieht. Auf den Kanten des Lösungsgraphen steht dabei die Anzahl der zu transportierenden Einheiten geschrieben. Unsere
Lösung ist ein b-Fluss x, der jeder Kante die Transportmenge zuordnet. Die Gesamtkosten
betragen
X
xij · cij = 26.
eij ∈E
13
2 Grundlagen
bi
(uij ; cij )
i
bj
bi
j
i
2
6
(4; 3)
(2; 3)
(4; 2)
xij
j
2
(3; 2)
1
bj
−4
6
4
1
(4; 3)
2
2
4
4
2
3
3
−2
−2
Ausgangsproblem
−4
optimale Lösung
Abbildung 2.7: Minimum Cost Flow Problem und die optimale Lösung
2.3 Residualgraphen und -netzwerke
Die nun folgenden Begriffe werden später beim Finden einer Lösung benötigt. Wenn nach
einer Lösung gesucht wird, so wird das Netzwerk modifiziert, indem man zum Beispiel
von einer Quelle das Angebot stückweise in die Richtung der Senken transportiert. Wir
sprechen dann von einem Pseudofluss, der auf den Graphen angewendet wird. Bis alle Angebote tatsächlich bei allen Konsumenten ankommen, haben wir es mit nicht zulässigen
Lösungen zu tun, bei denen das Angebot zum Beispiel noch auf dem Weg zum Konsumenten ist. Solche Zustände beinhalten neue Informationen und ändern die Ausgangssituation.
Weiterhin muss bei der Suche nach einer Lösung auch die Möglichkeit bestehen, getätigte
Flüsse rückgängig zu machen. Da man nicht sofort den optimalen Weg kennt, kann dies
durchaus vorkommen. In solchen Situation kann der gesamte Fluss oder nur ein Teil davon
zurückgeführt werden. Wir müssen festhalten, dass sich dabei neben den Gesamtkosten
des Flusses auch die Balancen und Restkapazitäten ändern. Wird nämlich ein Transport
storniert, entstehen auch keine Kosten mehr dafür.
Um solche Vorgänge abbilden zu können, werden wir als erstes den sogenannten Pseudofluss einführen. Damit können wir schon einige Einheiten auf unserem Graphen an den
Kanten entlang transportieren ohne eine Lösung darzustellen zu müssen. Die neuen Balancen und Restkapazitäten werden in einem neuen modifizierten Netzwerk festgehalten,
welches wir Residualnetzwerk nennen.
Definition 22 (Pseudofluss). Ein Fluss, der die Kapazitätseinhaltung erfüllt, heißt Pseudofluss [Jun04, Seite 295].
Ein Pseudofluss ist eine Abschwächung eines b-Flusses, da es nicht die Flusserhaltung
garantiert.
Als nächstes werden wir den Residualgraphen und das Residualnetzwerk definieren. Das
Residualnetzwerk wird alle Informationen bezüglich eines Flusses im Netzwerk festhalten. Insbesondere werden wir zum Finden einer Lösung mehrmals einen Fluss oder Pseudofluss verändern um uns schrittweise der Lösung zu nähern.Betrachten wir das Netzwerk
14
2.3 Residualgraphen und -netzwerke
bezüglich eines Pseudoflusses, ändern sich auch die Balancen der Knoten und die Restkapazitäten der Kanten. Hat der Pseudofluss einer Kante eij genau eine Einheit zugewiesen,
so können auf dieser Kante nur noch uij − 1 Einheiten transportiert werden. Im Residualgraphen besteht weiterhin die Möglichkeiten den Fluss zu annullieren. Daher müssen
zu jeder bestehenden Kante Rückwärtskanten eingeführt werden, auf dem der Fluss verringert werden kann. Die Kapazität der Rückwärtskante entspricht dem Fluss auf der
Vorwärtskante [AMO93, Seite 44].
Definition 23 (Vor- und Rückwärtskanten eines Digraphen). Ist ein Digraph G gegeben, so heißt jede Kante eij in E Vorwärtskante. Die Kante e←
ij , die in entgegengesetzter
Richtung von eij führt, heißt Rückwärtskante. Die Kantenmenge E ↔ enthält dabei alle
Vorwärts- und Rückwärtskanten. Der Graph G↔ entsteht aus dem Graphen G, indem
alle Rückwärtskanten dem Graphen hinzugefügt werden. Dabei können durchaus parallele
Kanten vorkommen [KV08, Seite 185].
Der Residualgraph wird auf dem Graphen G↔ aufbauen. Zu beachten ist jedoch, dass
im Graphen G↔ auch Kanten existieren können, die keine Kapazitäten besitzen. Wenn
wir einen leeren Fluss betrachten, dann haben in G↔ alle Rückwärtskanten keine Kapazität. Solche Kanten werden für uns nicht weiter interessant sein, so dass wir sie im
Residualgraphen ignorieren werden.
Definition 24 (Residualnetzwerk). Das Residualnetzwerk besteht aus den Mengen
N (x) = (G(x), b(x), `(x), u(x), c(x)). Insgesamt gelten für das Residualnetzwerk mit einem Fluss x und Netzwerk N = (G, b, `, u, c) folgende Bedingungen:
X
bi (x) = bi −
eij
X
xij −
∈δ + (i)
eji
xji
(1)
∈δ − (i)
− (x) = xij ∀ eij ∈ E : xij > 0
uij (x) = uij − xij ∀ eij ∈ E und u←
ij
(2)
− (x) = 0 ∀ eij ∈ E : xij > 0
`ij (x) = max(`ij − xij , 0) ∀ eij ∈ E und `←
ij
(3)
− (x) = −cij ∀ eij ∈ E : xij > 0
cij (x) = cij ∀ eij ∈ E und c←
ij
(4)
E(x) = E ↔ \ (∪ eij : uij = 0) und G(x) = (V, E(x))
(5)
[AMO93, Seite 44]
In einem Residiualnetzwerk werden die Informationen aus dem ursprünglichen Netzwerk
N = (G, b, `, u, c) durch einen Fluss x verändert und in N (x) festgehalten [BJG10, Seite
98]. Wir schauen uns diese Veränderungen nun genauer an:
1. Die Balancen haben das Angebot und die Nachfrage der einzelnen Knoten dargestellt. Durch einen positiven Fluss auf einer Kante, wird die Balance am Startknoten
vermindert und am Zielknoten erhöht. Den aktuellen Status der Balancen bezüglich
des Flusses x beschreibt b(x).
15
2 Grundlagen
2. Die Restkapazitäten werden im Residualgraphen in u(x) festgehalten. Wurde auf
einer Kante eine bestimmte Mengeneinheit durch den Fluss x transportiert, so verringert sich die Kapazität um diese Menge. Da wir auch die Möglichkeit haben, den
Fluss wieder zu verringern, wird die Kapazität der Rückwärtskante auf die transportierte Menge gesetzt.
3. Die untere Schranke verringert sich auf einer Vorwärtskante um die transportierten
Einheiten. Der Wert der unteren Schranke ist `(xij ) ≥ 0, da keine negativen Einheiten transportiert werden können. Rückwärtskanten haben stets die untere Schranke
− (x) = 0, weil sonst ein Transport auf dieser Kante getätigt werden müsste. Da es
`←
ij
sich aber um eine Rückwärtskante handelt, kann dieser Fall nur eintreten, wenn ursprünglich zu viele Einheiten auf der Vorwärtskante transportiert wurden, was nicht
erlaubt war.
4. Die Kosten sind nicht vom Fluss x abhängig. Die Kosten bleiben auf allen Vorwärtskanten erhalten, während sie auf den Rückwärtskanten genau die negative Größe
haben. Wird durch die Rückwärtskante der Fluss auf einer Kante verringert, sinken
die Kosten.
5. Als letztes erstellen wir den Graphen, in dem wir alle Kanten mit leeren Kapazitäten
ignorieren. Da auf diesen Kanten nichts transportiert werden kann, sind sie für uns
uninteressant. Zu beachten ist dabei, dass wir durch das Hinzufügen von Rückwärtskanten zwar die Anzahl der Kanten erhöhen aber mit der Streichung der Kanten mit
leeren Kapazitäten die Anzahl auch wieder verringern. Letztendlich werden wir im
Zusammenhang mit dem Residualgraphen wieder mit m = |E(x)| die Anzahl der
Kanten festhalten. Wie wir wissen haben auch u(x) und `(x) m Einträge.
An einem Beispiel schauen wir uns den Residualgraphen der Lösung aus der Abbildung
2.7 an.
(2; −3)
(2; −3)
i
2
(2; 3)
(3; 2)
1
4
(uij (x); cij (x))
(2; 3)
j
3
(4; −2)
(2; −3)
Abbildung 2.8: Residualgraph der Lösung aus Abbildung 2.7
In der Abbildung 2.8 ist der Residualgraph aus unserem ursprünglichen Netzwerk
bezüglich der optimalen Lösung x zu sehen. Im Residualgraphen sehen wir weiterhin die
Restkapazitäten und Restbalancen. Da unsere Lösung das gesamte Angebot und die gesamte Nachfrage befriedigt hat, haben alle Knoten i ∈ V die Balance bxi = 0. An den
16
2.3 Residualgraphen und -netzwerke
Kanten sehen wir, dass wir die Flüsse umkehren können. Die Rückwärtskanten haben die
negativen Kosten der Vorwärtskanten und als Kapazität den Fluss auf den Vorwärtskanten. Um die Rückwärtskanten hervorzuheben, wurden sie in der Abbildung 2.8 gekrümmt
eingezeichnet. Kanten, die keine Kapazitäten mehr haben, werden vom Residualgraphen
entfernt. Das hat in diesem Fall die Kanten e13 = (v1 , v3 ) und e24 = (v2 , v4 ) betroffen, da
die gesamte Kapazität auf diesen Kanten ausgeschöpft wurde. Wir sagen dann, dass die
Kanten gesättigt sind.
Lemma 1 (Fluss im Residiualnetzwerk). Sei x ein Fluss im Netzwerk N und xR ein Fluss
0
im Residiualnetzwerk N (x). Dann ist x = x ⊕ xR ein neuer Fluss in N mit:
0
R
xij = xij , wenn xR
ij = xji = 0
0
R
xij = xij + xR
ij , wenn xij > 0
0
R
xij = xij − xR
ji , wenn xji > 0
(2.1)
(2.2)
(2.3)
Wir gehen dabei davon aus, dass der Fluss im Residualnetzwerk für eine Kante aus E
nur auf der Vorwärtskante oder nur auf Rückwärtskante existiert [BJG10, Seite 137].
0
Insbesondere gilt für die Gesamtkosten von x dann
0
c(x ) = c(x) + c(xR )
[BJG10, Seite 138].
0
Beweis. Um zu zeigen, dass x ein Fluss in N ist, müssen wir die Kapazitätseinhaltung
0
zeigen. Da x ein Fluss ist, ist für denn Fall 2.1 auch x ein Fluss auf dieser Kante. Im Fall
R
2.2 wird der Vorwärtskante eij ein Fluss xR
ij zugeordnet. Da x ein Fluss ist, kann der
Fluss auf der Vorwärtskante maximal den Wert uij (x) = uij − xij haben, weil sonst die
Kapazitätseinhaltung verletzt wird. Demnach erfüllt auch der neue Fluss die Kapazitätseinhaltung auf dieser Kante, weil
0
xij = xij + xR
ij ≤ xij + uij − xij = uij
gilt. Analog gilt für denn Fall 2.3, dass xR auf einer Rückwärtskante maximal den Wert
0
uji (x) = xij haben kann und dadurch xij wieder die Kapazitätseinhaltung mit
0
xij = xij − xR
ij ≥ xij − xij = 0
17
2 Grundlagen
erfüllt. Für die Gesamtkosten folgt aus dieser Beobachtung dann:
0
c(x ) =
X
0
xij · cij =
eij ∈E
X
xij · cij +
eij ∈E
xR
ij =0
=
X
X
(xij + xR
ij ) · cij +
eij ∈E
xR
ij >0
xij · cij +
eij ∈E
= c(x) +
X
(xij − xR
ji ) · cij
eij ∈E
xR
ji >0
xR
ij · cij −
eij ∈E
xR
ij >0
X
X
X
xR
ji · cij
eij ∈E
xR
ji >0
R
x
xR
ij · cij
eij ∈E xR
= c(x) + c(xR )
2.4 Annahmen
Wir werden nach Algorithmen suchen, die unser Problem effizient lösen können. Dabei
können einige Annahmen für das Netzwerk vorausgesetzt werden. Wir werden diese Annahmen einführen und zeigen, dass sie keine Beeinträchtigung für eine Lösung darstellen.
Annahme 1 (Alle Daten sind ganzzahlig). Da die Algorithmen von Computern durchgeführt werden, ist es ohnehin nicht möglich echte reelle Zahlen abzubilden [Zul07]. Da
Computer nur über einen beschränkten Speicherplatz verfügen, können alle Nachkommastellen nicht dargestellt werden und müssen nach einer bestimmten Stelle abgeschnitten
und gerundet werden. Demnach existiert aber ein wohl möglich sehr großer Faktor, mit
dem alle Zahlen multipliziert werden können, so dass alle Zahlen ganzzahlig werden. Unter
Berücksichtigung dieser Beobachtung können wir annehmen, dass alle Werte am Anfang
des Problems ganzzahlig sind. Dies betrifft insbesondere die Balancen, Kapazitäten und
Kosten der Problemstellung [AMO93, Seite 297].
Annahme 2 (Die Kosten sind nicht negativ). Zum Transport der Einheiten auf den Kanten sind Kosten zu entrichten. Die Gesamtkosten werden letztendlich über die Qualität
der Lösung bestimmen. Dabei können wir annehmen, dass am Anfang alle Kosten cij ≥ 0
auf den Kanten nicht negativ sind. Sollte dieser Fall nicht gegeben sein, können wir durch
einen Pseudofluss die Gegebenheiten des Problems so umformen, dass alle Kosten nicht
negativ werden. Dazu betrachten wir alle Kanten, auf denen die Kosten negativ sind.
Dort sättigen wir mit einem Pseudofluss diese Kanten. Daraus resultiert, dass beim Startknoten eine zusätzliche Nachfrage in der Menge der Kapazität der Kante entsteht. Im
Zielknoten entsteht dagegen ein, um die gleiche Menge erhöhtes, Angebot. Die zusätzliche
Nachfrage und das zusätzliche Angebot werden mit der Balance des Knotens verrechnet.
Wie in Abbildung 2.9 zu sehen ist, wurde im Residiualnetzwerk die gesättigte Kante mit
den negativen Kosten entfernt und eine Rückwärtskante hinzugefügt. Die Rückwärtskante
18
2.4 Annahmen
hat dabei die gleiche Kapazität wie die ursprüngliche Vorwärtskante, da alle Einheiten abtransportiert wurden. Da die Kosten der Rückwärtskanten gerade der negative Kostenwert
der Vorwärtskanten sind, werden dadurch alle Kosten ins positive umgewandelt [AMO93,
Seite 40 und 297].
−4
−2
−4
3
1
3
1
(2, −4)
4
(4, 3)
(2, 4)
2
6
(4, 3)
2
Abbildung 2.9: Umformung eines Netzwerks mit negativen Kosten
Unser Pseudofluss x sättigt alle Kanten mit negativen Kosten. Es gilt
xij = uij ∀cij < 0 und
xij = 0 ∀cij ≥ 0.
Bezüglich diesem Pseudofluss bleiben im Residiualnetzwerk keine negativen Kosten erhalten. Dieses Residiualnetzwerk kann man nun als Ausgangsproblem für die Algorithmen
benutzen. Da diese Umformung immer möglich ist, nehmen wir an, dass im Ausgangsproblem alle Kosten nicht negativ sind.
Annahme 3 (Der Graph ist gerichtet). Theoretisch hätten wir auch Graphen benutzen
können, in denen ungerichtete Kanten existieren. Dass wir in Zusammenhang mit dem
Minimum Cost Flow Problem nur gerichtete Graphen betrachten, wird sich aber nicht
als Einschränkung erweisen. Sei dabei euij ∈ E eine ungerichtete Kante im Graphen G =
(V, E). Wir können nun diese Kante entfernen und durch zwei gerichtete Kanten eij und eji
ersetzen. Beide der neuen gerichteten Kanten erhalten die Kapazität und die Kosten der
ursprünglichen ungerichteten Kante. Wenn beiden Kanten ein positiver Fluss zugeordnet
werden sollte, also xij ≥ 0 und xji ≥ 0 gilt, können wir die Kante mit dem niedrigeren
Fluss subtrahieren. Dann gilt xneu
= xij − xji und xneu
= 0, falls xij > xji . Sind die
ij
ji
Flüsse gleich groß, können wir den Fluss auf beiden Kanten mit xij = xji = 0 annullieren.
Dadurch stellen wir sicher, dass ein positiver Fluss nur in einer Richtung existiert. Da nach
der Annahme 2 alle Kosten positiv sind, werden dadurch die Gesamtkosten minimiert und
es entstehen keine Einschränkungen für das Optimierungsproblem [AMO93, Seite 39 und
297].
Annahme 4 (Das gesamte Angebot und die gesamte Nachfrage stimmen überein). Im
Minimum Cost Flow Problem geht es um die Befriedigung aller Zulieferer und Abnehmer.
Sollte die Nachfrage größer als das Angebot sein, ist es ohnehin nicht möglich die Nachfrage zu befriedigen. Andersherum haben wir das Problem, dass das Angebot nicht komplett
geräumt werden kann. Beide Fälle führen dazu, dass kein b-Fluss gefunden werden kann.
19
2 Grundlagen
Daher wird im Minimum Cost Flow Problem dieser Fall nicht betrachtet. Durch das Vergleichen des gesamten Angebots und der Nachfrage können wir leicht die Lösbarkeit des
Problems überprüfen. Ist die Gleichung
X
bi = 0
i∈V
nicht erfüllt, so ist das Problem auch nicht lösbar [AMO93, Seite 297].
Annahme 5 (Die unteren Schranken der Kantenkapazitäten sind 0). Das Netzwerk N
bestand aus den Mengen (G, b, `, u, c). Wir können nun zeigen, dass wir für die unteren
Schranken immer den Wert `ij = 0 annehmen können. Jedes Problem mit positiven unteren
Schranken kann in diese Form umgeformt werden. Dazu führt man auf allen Kanten die
Menge der unteren Schranke `ij vom Startknoten zum Zielknoten. Danach sind auf einer
Kante noch uij − `ij Restkapazitäten übrig. Weiterhin haben sich auch die Balancen der
betroffenen Knoten verändert. Wir aktualisieren die Informationen, in dem wir uneu
=
ij
uij − `ij und bneu
= bj − `ij + `jk neu bestimmen und die alten Werte durch die neuen
i
ersetzen [BJG10, Seite 131]. Nach der Umformung enthält der Graph keine untere Schranke
mehr, sondern nur noch die neuen aktualisierten oberen Schranken uneu
ij .
2
−4
1
−3
1
3
1
3
(1, 2)
2
(1, 4)
2
Graph mit unteren Schranken
1
2
3
2
Graph ohne unteren Schranken
Abbildung 2.10: Eliminierung der unteren Schranken
Die untere Schranke hat die Mengeneinheiten angegeben, die mindesten auf einer Kante
transportiert werden mussten. Daher können wir diesen Transport ausführen und brauchen
dafür keine Rückwärtskante einzufügen. Insgesamt ändert diese Umformung daher nicht
die Problemstellung.
Im folgenden werden in Bezug auf die Annahmen 5 das Netzwerk N eines Minimum Cost
Flow Problems mit den Mengen (G, b, u, c) beschreiben und auf die unteren Schranken `
verzichten, da wir sie implizit mit `ij = 0 ∀ eij ∈ E voraussetzen können.
Annahme 6 (Es existieren keine parallelen Kanten). Wir können im Zusammenhang
mit dem Minimum Cost Flow Problem davon ausgehen, dass keine parallelen Kanten
existieren. Diese Einschränkung erspart uns eine komplexere Notation der Informationen
eines Netzwerkes [AMO93, Seite 37]. Weiterhin ist es durch Hinzufügen neuer Knoten und
Kanten in einen Graphen möglich, alle parallelen Kanten so zu transformieren, dass sie
nicht mehr parallel sind.
20
2.5 Netzwerkflussprobleme
Für jede parallele Kante wird ein Zwischenknoten und eine weitere Kante wie in Abbildung 2.11 hinzugefügt. Dadurch werden die parallelen Kanten eliminiert. Jeder Zwischenknoten hat einen Grad von 2 und bekommt eine Balance von 0, was bedeutet, dass
jede ankommende Einheit auch wieder abgegeben werden muss. Die neue Kante, die vom
Zwischenknoten zum Zielknoten führt, hat dabei die Kapazität der ursprünglichen Kante,
womit die Einheiten weitergeleitet werden können. Da die neue Kante zum Zielknoten keine Kosten hat, werden auch die Gesamtkosten nicht verändert. Mit dem gleichen Prinzip
kann man auch parallele Kanten, die in entgegengesetzter Richtung verlaufen, eliminieren.
0
(1, 1)
2
−2
2
1
2
1
3
Mit parallelen Kanten
−2
2
(1, 2)
(1, 2)
(1, 0)
(1, 1)
0
(1, 0)
4
Ohne parallele Kanten
Abbildung 2.11: Eliminierung von parallelen Kanten
Annahme 7 (Der Graph ist zusammenhängend). Sollte der Graph G = (V, E) nicht
zusammenhängend sein, so können wir den Graphen in mehrere Subprobleme aufteilen.
Dazu seien G1 = (V1 , E1 ), . . . , Gk = (Vk , Ek ) zusammenhängende Subgraphen von G mit
˙ . . ∪˙ Ek und V = V1 ∪.
˙ . . ∪V
˙ k . Lösen wir nun das Minimum Cost Flow Problem in
E = E1 ∪.
jedem Subgraphen G1 , . . . , Gk separat, so können wir die Lösung später zusammenführen.
Sind nämlich die Flüsse x1 , . . . , xk Lösungen der einzelnen Subgraphen, so ist x = x1 +
. . . + xk die Lösung für G.
2.5 Netzwerkflussprobleme
Das Minimum Cost Flow Problem wird als ein Netzwerkflussproblem bezeichnet [AMO93,
Seite 4]. Dabei gilt es eine Zielfunktion in einem Netzwerk zu minimieren. Neben dem
Minimum Cost Flow Problem gibt es weitere Netzwerkflussprobleme, die als Subproblem
des Minimum Cost Flow Problems bezeichnet werden können. Diese sind unter Anderem
das Shortest Path Problem und Maximum Flow Problem, weil sie als ein Spezialfall des
Minimum Cost Flow Problems formuliert werden können. Das Shortest Path Problem
sucht nach einem kürzesten Weg in einem Graphen, wobei die Länge des Weges äquivalent
zu den Kosten im Minimum Cost Flow Problem verstanden werden kann. Kosten und
Längen sind Bewertungen für Kanten [AMO93, Seite 6] und werden manchmal auch als
Gewichte bezeichnet [KV08, Seite 167].
Definition 25 (Shortest Path Problem). Im Shortest Path Problem geht es darum, in
einem Netzwerk N = (G, c) einen kürzesten Weg von einem Startknoten s ∈ V zu einem
21
2 Grundlagen
Zielknoten t ∈ V zu finden [KV08, Seite 167]. Eine Formulierung als LP hat die Form
min c(x) =
X
xij · cij
eij ∈E
X
u.d.N.
eij
X
xij −
∈δ + (i)
eji
xji =
∈δ − (i)



1


−1



0
wenn i = s,
wenn i = t,
sonst,
0 ≤ xij .
Aus der Formulierung des LP geht hervor, dass im Netzwerk nach einem Fluss x auf dem
kürzesten Weg gesucht wird, der eine Einheit vom Startknoten s zum Zielknoten t transportiert [AMO93, Seite 6]. Weiterhin muss x positiv sein, um keine negativen Einheiten
transportieren zu müssen.
Wir werden das Shortest Path Problem als einen Spezialfall vom Minimum Cost Flow
Problem formulieren. Sei das Netzwerk N = (G, c) für ein Shortest Path Problem gegeben
und sei o.B.d.A. der Knoten s = 1 ∈ V und t = n ∈ V . Betrachte nun das Minimum
Cost Flow Problem in einem Netzwerk NM CF P = (G, b, u, c), wobei G und c aus dem
ursprünglichen Netzwerk N stammen. Setze u> = (1, . . . , 1) und b> = (1, . . . , n). Dann
ist jede Lösung des Minimum Cost Flow Problems auch eine Lösung des Shortest Path
Problems [Jun04, Seite 323]. Insbesondere ist eine optimale Lösung im Minimum Cost
Flow Problem auch im Shortest Path Problem optimal.
Definition 26 (Maximum Flow Problem). Für das Maximum Flow Problem ist ein Netzwerk N = (G, u), sowie ein Startknoten s ∈ V und Zielknoten t ∈ V gegeben. Das Ziel ist
es, einen maximalen Fluss von s nach t zu finden. Der Fluss muss also möglichst viele Einheiten zwischen den Knoten s und t transportieren [KV08, Seite 183]. Die LP-Formulierung
lautet
max c(x) =
X
xsj −
esj ∈E
u.d.N.
X
xij −
eij ∈δ + (i)
X
X
xjs
ejs ∈δ − (i)
xji = 0 ∀i 6= s, i 6= t,
eji ∈δ − (i)
0 ≤ xij ≤ uij .
Auch das Maximum Flow Problem lässt sich als einen Spezialfall des Minimum Cost
Flow Problems darstellen. Dazu modifizierten wir den Graphen insofern, dass wir eine
neue Kante ets von t nach s hinzufügen. Sei der modifizierte Graph Gm = (V, E ∪ ets ),
b> = (0, . . . , 0), cij = 0 ∀eij ∈ E, cts = −1 und u wie im ursprünglichen Netzwerk N des
Maximum Flow Problems mit dem zusätzlichen Eintrag uts = ∞. Dann ist eine Lösung
des Minimum Cost Flow Problems mit dem Netzwerk NM CF P = (Gm , b, u, c) auch eine
Lösung des Maximum Flow Problems [AMO93, Seite 6]. Da alle Balancen 0 sind, muss
22
2.6 Optimalitätsbedingungen
jeder austretende Fluss aus s auch wieder dort ankommen. Um die Gesamtkosten zu
minimieren, muss der Fluss im Knoten t ankommen, um danach durch die neue Kante ets
zurück zu fließen. Durch jede Einheit die von t nach s zurückfließt werden die Gesamtkosten
genau um 1 vermindert.
2.6 Optimalitätsbedingungen
Im Minimum Cost Flow Problem geht es darum, eine kostenminimale Lösung zu finden.
Wurde eine Lösung gefunden und gibt es noch eine Möglichkeit die Gesamtkosten weiterhin zu senken, so hat es sich nicht um eine optimale Lösung gehandelt. Bei der Analyse des
Minimum Cost Flow Problems werden wir sehen, dass es einige Bedingungen gibt, die Auskunft geben, ob ein Lösung optimal ist. Das betrifft neben weiteren Indizien insbesondere
negative Kreise im Graphen.
Viele Algorithmen kontrollieren während der Berechnung einer Lösung sukzessiv diese
Bedingungen, um die Optimalität festzustellen. Erfüllt eine Lösung nämlich diese Bedingungen, so handelt es sich bereits um eine optimale Lösung.
2.6.1 Negative Kreise
Da uns ein gerichteter Graph vorliegt, betrachten wir nur gerichtete Kreise. Die Kanten
auf einem Kreis müssen weiterhin über eine positive Kapazität verfügen, damit ein Fluss
den Kanten einen positiven Wert zuweisen kann. Wenn wir einen positiven Fluss dem
Kreis C zuweisen, sprechen wir von einem C augmentierenden Fluss.
Definition 27 (Augmentierende Wege). Ist W ein gerichteter Weg in einem Netzwerk
N = (G, u) und existiert ein positiver Fluss x auf den Kanten von W , so ist W ein
augmentierender Weg in N . Gilt weiterhin
γ(W ) = min{uij : eij ∈ W },
so kann man den Weg W maximal um γ(W ) Einheiten augmentieren [BJG10, Seite 141].
Mit γ(W ) wird die maximale Kapazität auf den Kanten des Weges W bestimmt. Dafür
müssen wir auf dem Weg die Kante mit der kleinstmöglichen Kapazität finden, da ein
größerer Fluss die Kapazität genau dieser Kante überschreiten würde. Ist W ein Pfad
oder Kreis, spricht man entsprechend von augmentierenden Pfaden und Kreisen[BJG10,
Seite 162].
Ein Negativer Kreis ist ein Kreis C mit negativen Kosten c(C), der um mindesten eine
Einheit augmentiert werden kann. Praktisch an einem Kreis ist, dass wir an ihm entlang Einheiten transportieren können, ohne dass sich dabei die Balancen der betroffenen
Knoten verändern. Durch einen Fluss, der einen Kreis augmentiert, verändern sich durchaus die Kapazitäten der betroffenen Kanten. Weiterhin werden bezüglich des Flusses dem
Residualnetzwerk weitere Rückwärtskanten hinzugefügt [BJG10, Seite 163].
23
2 Grundlagen
Bereits Morton Klein hat darauf hingewiesen, dass Lösungen eines Minimum Cost Flow
Problems, in denen noch negative Kreise existieren, nicht optimal sein können [Kle67].
Satz 1 (Klein). Sei N = (G, u, b, c) eine Instanz des Minimum Cost Flow Problems. Ein
b-Fluss x hat genau dann minimale Kosten, wenn es im Residualnetzwerk N (x) keinen
augmentierbaren Kreis C mit negativen Kosten gibt [Kle67, Seite 206].
Beweis. Wie wir bereits wissen, bestimmt das Residiualnetzwerk N (x) den aktuellen Status des Netzwerkes N bezüglich eines Flusses x. Wenn es dann einen negativen Kreis C
im Residiualnetzwerk gibt, können wir diesen um γ(C) Einheiten augmentieren. Dadurch
ändern sich nicht die Balancen und auch die Kapazitätseinhaltung wird gewährleistet.
Sei xC der Fluss, der den negativen Kreis C um γ(C) Einheiten augmentiert. Für den
resultierenden Fluss x‘ ergeben sich geringere Gesamtkosten als x, da
0
x = x ⊕ xC
0
c(x ) = c(x) + c(xC ) < c(x)
| {z }
<0
und c(xC ) negativ war.
Andersherum kann man die Gesamtkosten von x in einem Netzwerk N (x) ohne einen
negativen Kreis nicht mehr verringern. Sei dazu xopt eine optimale Lösung für das Netzwerk
N . Da sowohl x als auch xopt einen b-Fluss darstellen, kann man die Differenz der Flüsse
durch eine Anzahl k ≤ m von augmentierenden Kreisen darstellen. Denn nur durch einen
Kreis kann erneut ein b-Fluss hergestellt werden, weil sonst die Flusserhaltung verletzt wird
und wir keine Lösung erhalten. Seien dazu x1 , . . . , xk Flüsse, wodurch Kreise C1 , . . . , Ck
so augmentiert werden können, dass für
xopt = x +
k
X
xi
i=1
gilt [BJG10, Seite 140]. Dann ist aber
c(x) ≤ c(xopt ) = c(x) +
k
X
i=1
c(x1 ) ,
| {z }
≥0
da die Kosten für jeden Kreis c(Ci ) nicht negativ sind.
2.6.2 Reduzierte Kosten
Es gibt eine weitere Bedingung über reduzierte Kosten, anhand der man erkennen kann,
ob es in einem Residualnetzwerk N (x) keine negativen Kreise mehr gibt. Ist dies der Fall,
so wissen aus Satz 1 von Klein, dass der Fluss x optimal ist [AMO93, Seite 308].
Definition 28 (Reduzierte Kosten und Potentiale). Existiert für ein Netzwerk N = (G, c)
24
2.6 Optimalitätsbedingungen
eine Knotenbewertung πi ∈ R für einen Knoten i ∈ V , so heißt π Potential. Ist π ein
Potential, so definieren wir mit cπij = cij + πi − πj die reduzierten Kosten für die Kante
eij ∈ E [KV08, Seite 172].
Ist C ein Kreis in einem Graphen G, so gilt für die reduzierten Gesamtkosten cπ (C) des
Kreises C:
c(C) =
X
cij =
eij ∈C
X
X
(cij + πi − πj ) =
eij ∈C
cπij = cπ (C).
(2.4)
eij ∈C
Die Potentiale π werden in einem Kreis genau einmal addiert und subtrahiert, wodurch
sie sich eliminieren. Reduzierte Kosten verändern demnach nicht die Kosten in einem Kreis
[AMO93, Seite 308].
Satz 2 (Optimalitätsbedingung für reduzierte Kosten). Sei x eine Lösung im Netzwerk
N = (G, c, b, u). Gibt es ein Potential π und sind die reduzierten Kosten cπij ≥ 0 im
Residualnetzwerk N (x) auf allen Kanten eij ∈ E(x) nicht negativ, so ist der Fluss x
optimal [Jun04, Seite 296].
Beweis. Auf einem Kreis verändern sich nach der Gleichung 2.4 nicht die Gesamtkosten.
Da cπij ≥ 0 ∀ eij ∈ E nicht negativ sind, ist auch jeder Kreis C nicht negativ [Jun04, Seite
297], weil
2.4
X
cπ (C) =
eij
cπij =
|{z}
∈C
≥0
X
cij ≥ 0.
eij ∈C
Daraus folgt, dass es keine negativen Kreise im Residiualnetzwerk N (x) gibt und der Fluss
x nach dem Satz 1 über negative Kreise optimal ist.
Weiterhin können wir zeigen, dass ein Optimum für die Zielfunktion cπ (x) auch optimal
für c(x) ist.
Lemma 2 (Optimalität für reduzierten Kosten). Sei π ein Potential und cπ die zugehörigen reduzierten Kosten. Ist dann im Netzwerk N = (G, b, u, c) ein b-Fluss x optimal für
die Zielfunktion cπ (x), so ist er auch optimal für c(x).
Beweis.
cπ (x) =
X
cπij · xij
eij ∈E
=
X
(cij + πi − πj ) · xij
eij ∈E
=
X
cij · xij +
eij ∈E
= c(x) +
X
πi · xij −
X
X
X
πi (
eij
∈δ(i)+
X
X
πj · xij
j∈V eij ∈δ(j)−
i∈V eij ∈δ(i)+
i∈V
= c(x) −
X
X
xij −
eij
xji )
∈δ(i)−
πi · bi .
i∈V
25
2 Grundlagen
Der Faktor
P
πi · bi ist für ein Potential π konstant. Daher ist ein Optimum für die
i∈V
reduzierten Kosten cπ auch optimal für c [Jun04, Seite 326].
2.6.3 Komplementärer Schlupf
Während die Optimalitätsbedingungen von negativen Kreisen und den reduzierten Kosten
auf dem Residiualnetzwerk aufbauen, liefert die Bedingung vom komplementären Schlupf
Hinweise darauf, wie ein Fluss x auf dem ursprünglichen Netzwerk aussehen muss.
Satz 3 (Komplementärer Schlupf). Ist ein Netzwerk N = (G, b, u, c) als Instanz des Maximum Flow Problems gegeben und existiert ein Potential π, so müssen für einen optimalen
Fluss x folgende Bedingungen gelten:
xij = 0, wenn cπij > 0
(2.5)
xij = uij , wenn cπij < 0
(2.6)
0 < xij < uij , wenn cπij = 0.
(2.7)
[AMO93, Seite 309]
Beweis. Wir können zeigen, dass die Bedingung vom komplementären Schlupf mit dem
über die reduzierten Kosten äquivalent ist. Sei zunächst xopt ein optimaler Fluss, der die
Bedingung über reduzierte Kosten erfüllt:
(2.5) Auf den Kanten eij ∈ E mit cπij > 0 muss der Fluss xopt
ij = 0 sein, da ansonsten
im entsprechenden Residualnetzwerk N (xopt ) eine Rückwärtskante e←
ij = eji mit
negativen reduzierten Kosten cπji = −cπij < 0 existieren würde.
π
(2.6) Analog zur Bedingung (2.5), muss der Fluss xopt
ij = uij für Kanten mit cij < 0
gesättigt sein, damit die Kante im Residiualnetzwerk entfernt wird. Dafür wird eine
Rückwärtskante mit positiven reduzierten Kosten cπji = −cπij > 0 eingefügt.
(2.7) Existiert hingegen ein nicht gesättigter positiver Fluss 0 < xopt
ij < uij , so ist im
Residiualnetzwerk sowohl die Kante eij , als auch die Rückwärtskante e←
ij = eji vorhanden. Damit die reduzierten Kosten im Residiualnetzwerk nichtnegativ sind, muss
für cπji ≥ 0 und cπij ≥ 0 wegen cπji = −cπij notwendigerweise cπji = cπij = 0 gelten.
[AMO93, Seite 310]
Nun sei ein b-Fluss x und Potential π gegeben, die die Bedingungen vom komplementärem Schlupf erfüllen. Dann sind analog alle reduzierten Kosten cπij ≥ 0 und x ist
optimal.
2.7 Dateiformate
Es gibt eine Reihe von Computerprogrammen, die in der Lage sind, Netzwerkflussprobleme
zu lösen. Um ein Maximum Flow Problem zu lösen, muss das Netzwerk N = (G, b, u, c) mit
26
2.7 Dateiformate
der Zielfunktion c(x) = c> x in einem bestimmten Dateiformat dem Computerprogramm
mitgeteilt werden.
Von November 1990 bis August 1991 gab es eine von der DIMACS1 gesponserte internationale Herausforderung, um Algorithmen für Netzwerkflussprobleme zu implementieren,
darunter auch für Maximum Flow Probleme [Joh93, Seite xi]. Dabei wurden die implementierten Programme mit Probleminstanzen in einem bestimmten Dateiformat getestet.
Das von der DIMACS definierte und spezifizierte MIN-Dateiformat für Maximum Flow
Probleme [Dim90, Kapitel 7] werden wir uns nun genauer anschauen.
Das Maximum Flow Problem wird in einer Textdatei mit der Endung .min gespeichert
und darf nur Zeichen aus dem Zeichensatz ASCII2 verwenden. Jede Zeile beginnt dabei
mit dem Buchstaben c, p, n oder a, gefolgt von mindestens einem Leerzeichen.
• Beginnt eine Zeile mit einem c, handelt es sich um eine Kommentarzeile. Diese Zeilen
werden von den Computerprogrammen ignoriert.
c Kommentar
• In jeder Datei muss genau eine Zeile mit einem p beginnen. Diese Zeile muss vor allen
Zeilen, die mit einem n oder a beginnen, stehen und stellt die Problemformulierung
dar. Die Zeile hat das Format
p min n m ,
wobei n = |V | und m = |E| die Anzahl der Knoten und Kanten wiedergeben.
• Für jede Quelle und Senke muss eine Zeile mit einem n am Anfang in der Datei
vorhanden sein. Knoten mit einer Balance von 0 müssen nicht angegeben werden.
Die Zeile hat in der Textdatei die Syntax
n i bi ,
mit der Knotennummer i ∈ V und Balance bi .
• Zeilen die mit einem a beginnen, halten die Information der Kanten, Kapazitätsschranken und Kosten fest. Für eine Kante eij ∈ E steht in der Datei eine Zeile mit
den Einträgen
a i j lij uij cij .
Das Netzwerk N = (G, b, u, c) aus Abbildung 2.6 wird wie folgt im MIN-Dateiformat
modelliert:
c Beispielnetzwerk mit 4 Knoten und 5 Kanten
p min 4 5
n 1 6
n 3 -2
n 4 -4
1
2
The Center for Discrete Mathematics and Theoretical Computer Science
American Standard Code for Information Interchange
27
2 Grundlagen
a 1 2 0 4 3
a 1 3 0 4 2
a 2 3 0 3 2
a 2 4 0 2 3
a 3 4 0 4 3
Ein weiteres Dateiformat um das Maximum Flow Problem zu modellieren, ist das LPDateiformat. Eine Spezifikation findet man unter anderem in einer Online-Dokumentation
von CPLEX [IBM09]. Viele Programme unterstützen diese beiden Dateiformate um ein
Maximum Flow Problem zu lösen. Als LP-Dateiformat können wir das Netzwerk aus
Abbildung 2.6 folgendermaßen modellieren:
Minimize
obj: 3 x12 + 2 x13 + 2 x23 + 3 x24 + 3 x34
Subject To
c1: x12 + x13 = 6
c2: - x12 + x23 + x24 = 0
c3: - x13 -x23 = -2
c4: x13 - x24 - x34 = -4
Bounds
0 <= x12 <= 4
0 <= x13 <= 4
0 <= x23 <= 3
0 <= x24 <= 2
0 <= x34 <= 4
End
28
3 Der Netzwerk Simplex Algorithmus
Der Netzwerk Simplex Algorithmus baut, wie der Name schon andeutet, auf dem SimplexAlgorithmus auf. Der Simplex-Algorithmus ist einer der mächtigsten Algorithmen, um
Optimierungsprobleme mit Schranken zu lösen [AMO93, Seite 402]. Der Netzwerk Simplex
Algorithmus wurde speziell für das Minimum Cost Flow Problem formuliert. Er wertet
die Struktur des Netzwerks direkt aus und ist für das Minimum Cost Flow Problem somit
wesentlich schneller als der Simplex-Algorithmus [Jun04, Seite 321].
Bevor wir uns den Netzwerk Simplex Algorithmus genauer anschauen, sind zunächst
weitere Definitionen notwendig, die wir im folgenden einführen werden. Der Netzwerk
Simplex Algorithmus arbeitet wie der Simplex-Algorithmus in zwei Phasen. Während in
der ersten Phase zunächst nach einer möglichen Lösung gesucht wird, optimiert die zweite
Phase die Lösung, bis das Optimum gefunden wird. Die Lösungen stellen im Algorithmus
so genannte Baumlösungen dar.
3.1 Definitionen und Sätze
Definition 29 (Freie und beschränkte Kanten). Sei x ein b-Fluss im Netzwerk N . Dann
heißt eine Kanten eij in E
frei, wenn 0 < xij < uij
und beschränkt, wenn xij = 0 oder xij = uij .
Freie Kanten besitzen einen positiven Fluss, sind aber nicht gesättigt. Insbesondere ist
im Residualgraphen G(x) sowohl die Vorwärts- als auch die Rückwärtskante vorhanden.
Beschränkte Kanten besitzen hingegen im Residualgraphen entweder eine Vorwärts- oder
Rückwärtskante [AMO93, Seite 405].
Definition 30 (Kreisfreie Lösung). Ist x eine b-Fluss in einem Netzwerk N , so heißt x
kreisfreie Lösung, wenn im Residualnetzwerk N (x) kein Kreis aus freien Kanten existiert.
Für jeden Kreis C im Residualnetzwerk gilt dann, dass mindestens eine Kante eij in
C beschränkt ist. Diese Kante besitzt entweder keine Vorwärts- oder Rückwärtskante.
Demnach kann man jeden Kreis im Residualnetzwerk nur in einer Richtung augmentieren
[AMO93, Seite 405].
Definition 31 (Baumlösung). Wir nennen in Zusammenhang mit einem spannenden
Baum (V, T ) im Netzwerk N einen Fluss x Baumlösung, wenn jede freie Kante eij in
29
3 Der Netzwerk Simplex Algorithmus
T ist. Darüber hinaus können auch beschränkte Kanten in T enthalten sein [AMO93,
Seite 405].
Jede Baumlösung ist auch eine kreisfreie Lösung, da alle freien Kanten in einem Baum
sind und Bäume keine Kreise besitzen.
Satz 4 (Existenz optimaler Baumlösungen). Gibt es im Netzwerk N einen b-Fluss x,
dann existiert eine optimale Baumlösung [Jun04, Seite 325].
Beweis. Wenn ein b-Fluss x existiert, dann gibt es unter allen möglichen Lösungen auch
eine optimale Lösung. Besitzt für den ersten Fall das Residualnetzwerk N (x) der optimalen
Lösung keinen Kreis aus freien Kanten, so können wir daraus eine Baumlösung erstellen.
Dazu seien zunächst alle freien Kanten eij in T . Nun können wir weitere beschränkte
Kanten zu T hinzufügen, bis (V, T ) ein spannender Baum wird.
Besitzt hingegen im zweiten Fall das Residualnetzwerk N (x) einen Kreis C aus freien
Kanten, so existieren zu allen Vorwärtskanten auch Rückwärtskanten auf dem Kreis. Nach
dem Satz 3 vom komplementären Schlupf muss jede freie Kanten eij in der optimalen
Lösung die reduzierten Kosten cπij = 0 haben. Weiterhin gilt, dass die Kosten des Kreises
C mit den reduzierten Kosten des Kreises übereinstimmen. Daraus folgt, dass die Kosten
des Kreises 0 ergeben:
c(C) = cπ (C) =
X
eij
cπij = 0.
|{z}
∈C
=0
Demnach können wir den Kreis C mit γ(C) in einer beliebigen Richtung mit einem Fluss
xC im Residualnetzwerk augmentieren. Dadurch wird eine Kante auf dem Kreis beschränkt
und wir können den Kreis aus freien Kanten entfernen, in dem wir einen neuen Fluss aus
0
x und xC bilden. Der neue Fluss x ist dann auch optimal, da
0
x = x ⊕ xC
0
c(x) = c(x) + c(xC ) = c(x )
| {z }
=0
ist. Auf diese Art und Weise können alle Kreise aus freien Kanten in N (x) entfernt werden,
bis keine Kreise aus freien Kanten mehr existieren. Danach können wir analog zum ersten
Fall wieder einen spannenden Baum (V, T ) mit allen freien Kanten erstellen.
Beispiel
Wir schauen uns nochmal das Ausgangsproblem und die optimale Lösung aus Abbildung
2.7 an. Hier können wir nun freie Kanten erkennen und eine Baumlösung bestimmen.
Wie wir in Abbildung 3.1 sehen, gibt es drei Möglichkeiten um eine Baumlösung zu
bestimmen. Dabei muss jede freie Kante eij in der Menge T sein. Um mit T einen spannenden Baum zu bilden, können wir zu T weitere Kanten hinzufügen. In der Abbildung
3.1 ist dabei T1 = (e12 , e13 , e34 ), T2 = (e12 , e23 , e34 ) und T3 = (e12 , e24 , e34 ). Jedes mal
30
3.1 Definitionen und Sätze
2
6
4
1
2
3
4
2
−4
0
4
1
4
2
2
4
2
0
4
3
3
−2
0
Optimale Lösung und Kantenflüsse
Ausgangsproblem und Kapazitäten
2
2
2
1
4
1
4
2
3
3
Freie Kanten mit Restkapazitäten
Baum T1 einer Baumlösung
2
2
1
4
1
4
3
3
Baum T2 einer Baumlösung
Baum T3 einer Baumlösung
Abbildung 3.1: Baumlösungen
mussten wir zu den freien Kanten e12 und e34 nur eine beschränkte Kante hinzufügen, da
der spannende Baum n − 1 = 3 Kanten besitzt.
Mit dem spannenden Baum (V, T ) einer Baumlösung können wir jeden Knoten im Graphen erreichen. Um später auf die einzelnen Knoten und Kanten explizit zugreifen zu
können, sortieren wir die Knoten und Kanten. Bei der Sortierung müssen wir letztendlich
an einem beliebigen Knoten beginnen. Die Sortierung von Knoten und Kanten wird Traversierung genannt. Eine Traversierung ist mit dem Graph-Scanning-Algorithmus möglich.
Dabei kann sowohl eine Breitensuche als auch eine Tiefensuche genutzt werden [KV08, Seite 27 bis 30].
Definition 32 (Vorgänger, Nachfolger und Höhe im spannenden Baum). Sei r ein beliebiger Wurzelknoten im spannenden Baum (V, T ). Ausgehend von r kann mit einer Breitenoder Tiefensuche für jeden Knoten i im Graphen ein anderer Knoten als Nachfolger nach(i)
bestimmt werden. Der letzte besuchte Knoten bekommt als Nachfolger wieder den Wurzelknoten r. Alle Nachfolger bilden somit eine Reihenfolge der Knoten. Außer dem Wurzelknoten r haben auch alle Knoten i einen anderen Knoten als Vorgänger vor(i). Ist eij
eine Kante in T , die auf dem Weg von j nach r liegt, so gilt vor(j) = i. Wenn eij hingegen
eine Kante in T ist, die auf dem Weg von i nach r liegt, so gilt vor(i) = j. Die Vorgänger
beziehen sich also auf den nächsten Knoten auf dem Weg zur Wurzel unabhängig von der
31
3 Der Netzwerk Simplex Algorithmus
Richtung der Kante. Weiterhin verfügt jeder Knoten über eine Baumhöhe. Die Baumhöhe
gibt die Anzahl der Kanten auf dem Weg von einem Knoten zum Wurzelknoten an. Der
Wurzelknoten r hat dabei die Höhe 0 und wir schreiben hoehe(r) = 0 [AMO93, Seite 409].
Wir betrachten erneut unser Beispiel und wählen T1 aus der Abbildung 3.1 als die
Baumlösung. Als Startknoten r wählen wir den Knoten 1 ∈ V .
1
2
3
4
Abbildung 3.2: Traversierung von T1 aus Abbildung 3.1
i∈V
vor(i)
nach(i)
hoehe(i)
1
2
0
2
1
3
1
3
1
4
1
4
3
1
2
Tabelle 3.1: Daten für den Baum T1 aus Abbildung 3.2
Nachdem wir im Knoten 1 ∈ V starten, bewegen wir uns wie in der Abbildung 3.2 durch
die Knoten 2 und 3 nach 4. Die gestrichelten Linien geben an, in welcher Reihenfolge wir die
Knoten besuchen. In diesem Zusammenhang ist der Knoten 3 der Nachfolger von Knoten
2, weil der Knoten 3 vom Knoten 2 aus besucht wird. Dafür schreiben wir nach(2) = 3.
Trotzdem ist der Knoten 1 und nicht 2 der Vorgänger von Knoten 3, weil auf dem Weg
zur Wurzel die erste Kante zum Knoten 1 führt und es gilt vor(3) = 1. Weiterhin verfügt
jeder Knoten über eine Baumhöhe. Der Startknoten 1 ∈ V hat dabei initial die Höhe 0.
Entsprechend haben die Knoten 2 und 3 die Höhe 1 und der Knoten 4 die Höhe 2.
Wir haben die Informationen in der Tabelle 3.1 zusammengefasst. Diese Informationen
werden vor allem in Algorithmen nützlich sein, da Sie die Informationen über einen spannenden Baum (V, T ) festhalten. Auch bei der Implementation von Computerprogrammen
wird diese Datenstruktur genutzt [AMO93, Seite 409].
Definition 33 (Baumstruktur). Eine Baumstruktur besteht für ein Graphen G = (V, E)
aus drei Kantenmengen (T, L, U ) mit E = T ∪˙ L ∪˙ U , wobei (V, T ) ein spannender Baum
32
3.1 Definitionen und Sätze
ist. In einem Netzwerk ist x der Fluss der Baumstruktur (T, L, U ), wenn
xij beliebig für eij ∈ T
xij = 0 für eij ∈ L
xij = uij für eij ∈ U
gilt. Während (V, T ) einen spannenden Baum mit allen freien und eventuell weiteren
Kanten darstellt, beinhaltet L die Menge der restlichen Kanten ohne einen Fluss und
U die Mengen der restlichen gesättigten Kanten. Besteht T nur aus freien Kanten, so
heißt die Baumstruktur nicht degeneriert und ansonsten degeneriert. Ist x ein b-Fluss,
so heißt die Baumstruktur zulässig und der Fluss ist bezüglich (V, T ) eine Baumlösung
[AMO93, Seite 408].
Im Gegensatz zu zulässigen nicht degenerierten Baumstrukturen kann in einer zulässigen degenerierten Baumstruktur der Fluss im spannenden Baum nicht in eine beliebige
Richtung geändert werden, weil in T beschränkte Kanten enthalten sind. Für einen Fluss
existieren im Residualnetzwerk also Kanten mit entweder Vorwärts- oder Rückwärtskanten.
Mit der Baumstruktur ist es möglich, einen Fluss eindeutig zu beschreiben.
Satz 5 (Fluss der Baumstruktur ist eindeutig). Für jede Baumstruktur existiert im Netzwerk genau ein Fluss. Der Fluss x kann aus den Mengen (T, L, U ) rekonstruiert werden
[KV08, Seite 238] [AMO93, Seite 413].
Beweis. Aus der Definition 33 für des Fluss x einer Baumstruktur folgt, dass x auf allen
Kanten in L leer und in U gesättigt ist. Wir betrachten nun den Fluss auf den Kanten
vom spannenden Baum (V, T ). Entfernen wir eine beliebige Kante eij aus T , so zerfällt
der spannende Baum in zwei neue Teilbäume T1 und T2 , wobei i ∈ V (T1 ) und j ∈ V (T2 )
sei. Für das gesamte Angebot oder die gesamte Nachfrage bT1 und bT2 der Teilbäume T1
und T2 gilt
bT1 =
X
bi +
X
i∈V (T2 )
uij −
eij ∈U
j∈V (T1 )
i∈V (T1 )
bT2 =
X
bi +
X
eij ∈U
j∈V (T2 )
X
uij und
eij ∈U
i∈V (T1 )
uij −
X
uij ,
eij ∈U
i∈V (T2 )
weil durch die Kanten in U weitere Einheiten in die Teilbäume T1 und T2 an- oder abtransportiert werden können. Im spannenden Baum (V, T ) ist jeder Knoten durch einen
anderen Knoten mit den Kanten in T erreichbar. Da das gesamte Angebot mit der gesamten Nachfrage übereinstimmt, muss der Fluss nun auf den Kanten in T groß genug sein,
33
3 Der Netzwerk Simplex Algorithmus
um das Angebot zur Nachfrage transportieren zu können. Dafür erhalten wir durch
bT1 + bT2 = 0
bT1 = bT2
und
xij = bT1 = bT2 .
den Fluss
Die Kante eij war die einzige Kante, die von T1 nach T2 führt und für die der Fluss
noch angepasst werden konnte. Da eij in T beliebig gewählt war, ist dadurch der Fluss
xij auf jeder Kante eij eindeutig festgelegt. Erfüllt der Fluss die Bedingung über die
Kapazitätseinhaltung, so ist die Baumstruktur zulässig.
Aus Satz 5 folgt nun, dass wir den Fluss der Baumstruktur in einem Netzwerk eindeutig berechnen können. Wir schauen und als nächstes den Algorithmus 1 zur Berechnung
vom Fluss der Baumstruktur an [AMO93, Seite 414]. Der Algorithmus benutzt dabei die
Informationen über die Vorgänger und Nachfolger der Knoten.
Algorithmus 1 : Berechnung vom Fluss der Baumstruktur
Eingabe : Netzwerk N , Wurzelknoten r ∈ V , Baumstruktur (T, L, U )
Ausgabe : Fluss x
0
1
2
3
4
5
6
7
bi := bi ∀ i ∈ V
for all eij ∈ L do
xij := 0
for all eij ∈ U do
xij := uij
0
0
bi := bi − uij
0
0
bj := bj + uij
0
8
9
10
11
12
13
14
15
T := (V, T )
0
while V (T ) 6= {r} do
0
j ∈ V (T ) \ {r} mit |δT 0 (i)| = 1
i := vor(j)
0
if eij ∈ E(T ) then
0
xij := −bj
else
0
xij := bi
0
0
0
bi := bi + bj
0
0
0
T := (E(T ) \ δ(j), V (T ) \ j)
16
17
Der Algorithmus setzt zunächst die Flüsse für die Kanten in L und U gemäß der Definition 33 der Baumstruktur. Der Fluss ist auf den Kanten in L leer und in U gesättigt.
Beim Algorithmus werden die Balancen für das Residualnetzwerk aktualisiert, in dem in
Zeile 6 und 7 die an- und abtransportierten Einheiten verrechnet werden. Die neuen Ba0
lancen werden in der Variable b festgehalten. In der Schleife ab Zeile 9 wird jedes mal
34
3.1 Definitionen und Sätze
ein Blatt aus dem spannenden Baum gewählt. Wie wir aus Satz 5 wissen, muss der Fluss
xij für eine Kante im Baum bT1 = bT2 sein, wenn eij in T den spannenden Baum in zwei
Teilbäume T1 und T2 aufteilt. Da wir ein Blatt im spannenden Baum betrachten, besteht
0
einer der Teilbäume nur aus einem Knoten. Ist j ein Blatt im aktuellen Baum T , so gilt
0
0
bj = bT1 = bT2 und wir können xij = bj setzen, wenn die Kante eij von i nach j führt.
0
0
Andernfalls setzen wir xji = −bj , da so wieder erzielt wird, dass bj Einheiten vom Knoten
i nach j gelangen. Am Ende in Zeile 16 werden die Balancen für den Knoten i wieder
aktualisiert, in dem die neu transportierten Einheiten verrechnet werden. In Zeile 17 wird
schließlich der Knoten j und die zu j inzidente Kante aus T entfernt, da der Knoten j inzwischen keine Balance mehr hat und somit abgearbeitet wurde. Am Ende ist x ein Fluss,
der die Kapazitätseinhaltung erfüllt. Gilt für x zusätzlich die Flusserhaltung, so handelt
es sich um einen b-Fluss.
Wie beim Satz 3 über den komplementären Schlupf, lässt sich auch für eine Baumstruktur eine Optimalitätsbedingung formulieren.
Satz 6 (Optimale Baumstruktur). Sei π ein Potential. Dann ist eine Baumstruktur für
ein b-Fluss optimal, wenn sie folgende Bedingungen erfüllt:
cπij = 0, wenn eij ∈ T
(3.1)
cπij ≥ 0, wenn eij ∈ L
(3.2)
cπij ≤ 0, wenn eij ∈ U
(3.3)
[Jun04, Seite 326].
Beweis. Sei x ein Fluss für die Baumstruktur (T, L, U ), der die Bedingungen aus Satz 6
erfüllt. Wir können zeigen, dass für alle b-Flüsse x∗ die Ungleichung cπ (x) ≤ cπ (x∗ ) gilt.
X
X
cπij ·x∗ij +
cπij · x∗ij +
cπij · x∗ij
|{z}
eij ∈T
eij ∈L
eij ∈U
=0
X
X
=
cπij · x∗ij +
cπij · x∗ij
cπ (x∗ ) =
X
eij ∈L
≥
eij
=
eij ∈U
X
cπij · uij
|{z}
|{z}
∈U
X
≤0
≥x∗ij
cπij · xij
eij ∈E
= cπ (x)
Da x optimal für die reduzierten Kosten ist, ist x nach Lemma 2 auch optimal für die
Zielfunktion c(x).
Nach dem Satz 6 über die optimale Baumstruktur muss für die Optimalitätsbedingung
35
3 Der Netzwerk Simplex Algorithmus
3.1 jede Kante im spannenden Baum reduzierte Kosten in Höhe von 0 haben. Wir werden
zeigen, dass für jede Baumstruktur diese Bedingung erzielt werden kann.
Satz 7 (Potential der Baumstruktur). Sei (T, L, U ) eine Baumstruktur im Netzwerk N
und r ein beliebiger Wurzelknoten. Dann ist das Potential π mit den Bedingungen
πr = 0 und
cπij = 0 ∀ eij ∈ T
eindeutig [Jun04, Seite 329].
Beweis. Wir schauen uns zunächst an, wie die reduzierten Kosten einer Kante eij in E für
ein gegebenes Potential π definiert sind. Wenn wir nun einen konstanten Faktor zu allen
Potentialen dazu addieren, ändern sich nicht die reduzierten Kosten, weil aus
cπij = cij + πi − πj
und
πineu = πi + k
π neu
cij
k ∈ R, ∀ i ∈ V
= cij + (πi + k) − (πj + k) = cij + πi − πj = cπ
folgt. Mit dieser Beobachtung ist es möglich, für eine Baumstruktur (T, L, U ) reduzierte
Kosten cπ zu definieren, in denen alle Kanten im spannenden Baum (V, T ) die Bedingung
3.1 erfüllen. Bestimmen wir nämlich die reduzierten Kosten für eine mit dem Knoten r
inzidente Kante eri im spannenden Baum mit
!
cπri = cri + πr − πi = cri − πi = 0
πi = cri ,
in dem wir das Potential πi für den Knoten i anpassen, können wir das Potential für jeden
anderen Knoten sukzessiv berechnen. Da (V, T ) ein spannender Baum ist, gibt es auf jeder
Kante eij in T noch genau ein zu bestimmendes Potential πi oder πj für den Knoten i
oder j.
Mit diesem Satz können wir das Potential und die reduzierten Kosten für den praktischen
Nutzen interpretieren. In einer Baumstruktur gibt das Potential die Kosten c(P ) des Pfades
P von dem Wurzelknoten r zu einem beliebigen Knoten j auf den Kanten im spannenden
Baum (V, T ) an. Jeder r-j-Pfad P ist auf den Kanten in T eindeutig, weil (V, T ) ein
spannender Baum ist. Die reduzierten Kosten cπij geben für eine Kante eij die Differenz
0
0
zwischen den Kosten c(P ) und c(P ) an, wobei P ein r-j-Pfad ist, der aus dem r-i-Pfad
in T und zusätzlich der Kante eij besteht [KV08, Seite 239]. Insbesondere besteht der r0
j-Pfad P immer aus Kanten in T , wobei in P nur die Kante eij nicht in T sein muss. Aus
diesem Grund müssen für das eindeutig bestimmte Potential π die reduzierten Kosten
0
cπij auf einer Kante eij in T immer 0 sein, da in diesem Fall P und P identisch sind.
36
3.1 Definitionen und Sätze
0
Betrachten wir für eine beliebige Kante eij in E die r-j-Pfade P und P , so geben die
reduzierten Kosten cπij Auskunft darüber, was es Kosten würde, wenn man eine Einheit
0
von r nach j statt über den Pfad P über den Pfad P senden würde [AMO93, Seite 420].
Ausgehend von der Eindeutigkeit des Potentials einer Baumstruktur, können wir es
mit einem Algorithmus berechnen. Für den spannenden Baum (V, T ) einer Baumstruktur
(T, L, U ) sortieren wir dafür die Knoten und Kanten und gehen diese anschließend systematisch durch, um cπij = 0 für alle Kanten eij in T zu erzielen. Dazu setzen wir für jeden
Knoten die Informationen der Vorgänger und Nachfolger voraus.
Algorithmus 2 : Berechnung vom Potential der Baumstruktur
Eingabe : Spannender Baum (V, T ), Wurzelknoten r in V
Ausgabe : Potential π
8
πr := 0
j := nach(r)
while j 6= r do
i := vor(j)
if eij ∈ E then
πj := πi + cij
else
πj := πi − cji
9
j := nach(j)
1
2
3
4
5
6
7
Das Ziel war die Gewährleistung der Bedingung 3.1 vom Satz 6. Dazu müssen die reduzierten Kosten cπij auf alle Kanten eij in T den Wert 0 haben. Initial bekommt das Potential
πr vom Wurzelknoten den Wert 0. Daraus ergeben sich für eine mit dem Wurzelknoten
inzidente Kante eri in T folgende reduzierte Kosten:
cπri = cri + πr − πi = cri − πi
Damit cπri den Wert 0 erhält, muss das Potential πi vom Knoten i als Wert die Kosten
cri der Kante eri haben. Dieser Schritt geschieht im Algorithmus 2 in Zeile 6. Für den
Fall einer Rückwärtskante wird Zeile 8 ausgeführt. Letztendlich wird sukzessiv folgendes
Gleichungssystem gelöst:
!
cij + πi − πj = 0
πj = πi + cij
(3.4)
πi = πj − cij
(3.5)
Für den Fall einer Vorwärtskante ist πi bekannt und mit der Gleichung 3.4 kann πj bestimmt werden. Bei Rückwärtskanten ist πj bekannt und mit der Gleichung 3.5 wird πi
bestimmt.
Mit dem Algorithmus 2 zur Berechnung vom Potential π der Baumstruktur können
37
3 Der Netzwerk Simplex Algorithmus
wir für jede Baumstruktur (T, L, U ) eines Netzwerks N auch die reduzierten Kosten cπ
berechnen. Für die Optimalitätsbedingungen einer Baumstruktur ist mit dem berechneten
Potential für die Kanten in T nichts zu zeigen, da diese nach Satz 7 bereits alle 0 sind
und somit die Bedingung 3.1 erfüllen. Demnach kann nur eine Kante in L oder U die
Optimalitätsbedingungen verletzen.
Definition 34 (Verletzende Kante). Sei (T, L, U ) eine Baumstruktur im Netzwerk N und
π ein Potential. Gilt für eine Kante ek` die Bedingung
ek` ∈ L mit cπk` < 0 oder
ek` ∈ U mit cπk` > 0,
so handelt es sich um eine verletzende Kante [AMO93, Seite 416].
3.2 Ausgangslösung
Eine Baumstruktur stellt im Netzwerk Simplex Algorithmus eine Lösung dar. Während im
Simplex-Algorithmus in der Phase 1 eine zulässige Ausgangslösung bestimmt wird, brauchen wir für den Netzwerk Simplex Algorithmus eine zulässige Baumstruktur [Jun04, Seite
327]. Eine Ausgangslösung für den Netzwerk Simplex Algorithmus kann auf verschiedenen
Wegen bestimmt werden. So ist es möglich die Phase 1 des Simplex-Algorithmus auszuführen und aus dem resultierenden Fluss eine Baumstruktur zu bilden. Man kann auch
ein Max-Flow-Problem auf dem zugrunde liegendem Netzwerk lösen. Die algorithmisch
schnellste Variante ist jedoch eine künstliche Konstruktion einer zulässigen Baumstruktur, in dem man das Netzwerk N = (G, b, u, c) modifiziert [KV08, Seite 239].
Definition 35 (Hilfsnetzwerk). Ist ein Netzwerk N = (G, b, u, c) gegeben, so können wir
daraus ein Hilfsnetzwerk N h = (Gh , b, uh , ch ) generieren. Der Graph Gh = (V, E ∪ E a )
entsteht aus G mit weiteren künstlichen Kanten E a . Sei r ein beliebiger Wurzelknoten in
V . Das Hilfsnetzwerk besteht dann aus den folgenden Mengen:
Ea =
[
bi ≥0
eair ∪
[
eari ∀ i ∈ V \ {r}, mit künstlichen Kanten ea ∈ E a
(3.6)
bi <0
uhij = uij ∀ eij ∈ E , uheair = bi + 1 ∀ eair ∈ E a und uheari = −bi ∀ eari ∈ E a
(3.7)
chij = cij ∀ eij ∈ E und cheaij = |V | · cmax ∀ eaij ∈ E a
(3.8)
Im Graphen Gh wurde zunächst ein Wurzelknoten r ausgewählt. Anschließend wurde
jeder andere Knoten durch eine neue künstliche Kante ea ∈ E a mit dem Wurzelknoten r
verbunden. Der neue Graph Gh besteht demnach aus n = |V | Knoten und m = |E|+|V |−1
Kanten [KV08, Seite 239] [Jun04, Seite 327] [AMO93, Seite 415].
38
3.2 Ausgangslösung
Die Idee hinter dem Hilfsnetzwerk ist die Konstruktion einer teuren zulässigen Baumstruktur [KV08, Seite 239]. Durch die Wahl eines Wurzelknotens versuchen wir im zugrunde liegendem Hilfsnetzwerk die Möglichkeit zu schaffen, den gesamten Transport über den
Wurzelknoten abzuwickeln. Da der Algorithmus eine Lösung iterativ optimiert, würde eine optimale Lösung im Minimum Cost Flow Problem mit einem Fluss über diese teuren
künstlichen Kanten niemals vorkommen [AMO93, Seite 297]. Nun schauen wir uns die
einzelnen Schritte bei der Konstruktion eines Hilfsnetzwerks genauer an.
(3.6) Damit das gesamte Angebot nach r transportiert werden kann, erstellen wir neue
künstliche Kanten aus allen Quellen nach r. Danach erstellen wir neue künstliche
Kanten von r zu allen Senken, um die gesamte Nachfrage befriedigen zu können. Weiterhin erstellen wir auch Kanten von den Durchflussknoten nach r, um später einen
spannenden Baum T aus dem Knoten r und den Kanten in δ(r) zu erstellen. Mit T
werden wir später einen Kanditaten für den spannenden Baum einer Baumstruktur
haben.
(3.7) Hier werden die Kapazitäten der neuen Kanten gerade so groß definiert, damit das
Angebot von einer Quelle nach r angeliefert und die Nachfrage an die Senken von r
abtransportiert werden kann. Die Kanten von einem Durchflussknoten nach r bekommen auch eine Kapazität, damit bei einem Fluss x im Residualnetzwerk die Kanten
erhalten bleiben. Wie wir aus dem Schritt 5 über die Definition 24 von Residualnetzwerken wissen, werden Kanten ohne Kapazitäten ignoriert. Diese Kanten werden bei
der Bildung von einem spannenden Baum im Hilfsnetzwerk noch benötigt.
(3.8) Die Kosten werden für die neuen Kanten so groß gewählt, dass ein Transport über
jeden Pfad ohne die neuen Kanten immer günstiger ist. Dadurch erzielen wir, dass
im Minimum Cost Flow Problem keine optimale Lösung über den Weg der neuen
Kanten erreicht werden kann.
Wir schauen uns das ursprüngliche Beispiel aus Abbildung 2.6 an und konstruieren daraus ein Hilfsnetzwerk. Auf den Kanten stehen dabei die Informationen der Kapazitäten
und Kosten in Form von (uij , cij ). Da das Hilfsnetzwerk die Informationen aus dem ursprünglichen Netzwerk beinhaltet, beschreiben wir im Hilfsnetzwerk in der Abbildung 3.3
nur die Informationen für die künstlichen Kanten. Für unser Beispiel wählen wir den
Wurzelknoten r = 1.
Aus der Annahme 6 wissen wir, dass im Ausgangsproblem keine parallelen Kanten
existieren. Durch die neuen künstlichen Kanten können aber durchaus parallele Kanten
vorkommen. An unserem Beispiel sehen wir, dass zwsichen den Knoten 1 und 2 die Kanten
e12 ∈ E und ea21 ∈ E a und zwischen den Knoten 1 und 3 die Kanten e13 ∈ E und ea13 ∈ E a
parallel sind. Um eine Kante eindeutig zu definieren, haben wir die Notation eaij ∈ E a
für die neuen künstlichen Kanten eingeführt. Dadurch besitzt jede Kante eine eindeutige
Bezeichnung. So schreiben wir zum Beispiel für einen Fluss auf einer künstlichen Kante
39
3 Der Netzwerk Simplex Algorithmus
(4, 12)
0
(1, 12)
2
6
(4, 3)
(2, 3)
(3, 2)
1
4
(4, 2)
2
−4
1
4
(4, 3)
(2, 12)
3 −2
3
Hilfsnetzwerk
Ausgangsproblem
Abbildung 3.3: Konstruktion eines Hilfsnetzwerks
eaij ∈ E a auch xeaij , um zwischen den parallelen Kanten zu unterscheiden. Analoges gilt
auch für die Kapazitäten u und Kosten c.
Satz 8 (Baumstruktur im Hilfsnetzwerk). Für ein Minimum Cost Flow Problem mit dem
Netzwerk N sei N h das Hilfsnetzwerk mit dem Wurzelknoten r. Dann ist im Hilfsnetzwerk
(T, L, U ) eine zulässige Baumstruktur mit
T = Ea,
L=E
und
U =∅
[KV08, Seite 239] [Jun04, Seite 330].
Beweis. In der Baumstruktur im Hilfsnetzwerk sind alle ursprünglichen Kanten in L und
alle künstlichen Kanten in T enthalten. Weiterhin bilden die künstlichen Kanten einen
spannenden Baum (V, E a ), weil |E a | = |V (Gh )| − 1 ist und (V, E a ) keinen Kreis enthält.
Berechnen wir mit dem Algorithmus 1 einen Fluss x für die Baumstruktur, so ist x ein
b-Fluss. Da alle Knoten außer r im spannenden Baum (V, T ) Blätter sind, gilt nämlich
0 ≤ xrj = −bj ≤ urj = −bj
0 ≤ xir = bi ≤ uir = bi + 1
∀ erj ∈ T
∀ eir ∈ T .
Damit erfüllt der Fluss x die Flusserhaltung und Kapazitätseinhaltung auf den künstlichen
Kanten. Da alle ursprünglichen Kanten in L sind, ist der Fluss auf diesen Kanten 0. Für
die Kantenmenge U muss kein Fluss definiert werden, da die Menge U leer war. Insgesamt
ist dann x ein b-Fluss im Hilfsnetzwerk N h .
Definition 36 (Ausgangslösung). Die Baumstruktur im Hilfsnetzwerk aus Satz 8 ist die
Ausgangslösung für den Netzwerk Simplex Algorithmus [AMO93, Seite 415].
An dem Beispiel aus der Abbildung 3.3 können wir die Konstruktion einer zulässigen
Baumstruktur im Hilfsnetzwerk veranschaulichen. Mit dem Algorithmus 1 berechnen wir
anschließend einen Fluss x.
40
3.2 Ausgangslösung
0
0
2
6
−4
(1, 12)
(4, 12)
1
4
(2, 12)
2
0
0
1
4
4
2
3
3
−2
0
Spannender Baum (V, T ) im Hilfsnetzwerk
Fluss x im Hilfsnetzwerk
Abbildung 3.4: Ausgangslösung
In der Abbildung 3.4 stehen im spannenden Baum (V, T ) auf den Kanten die Informationen der Kapazitäten und Kosten in Form von (uij , cij ) und auf dem Fluss die zu
transportierenden Einheiten xij . Die Gesamtkosten betragen c(x) = 4 · 12 + 2 · 12 = 72.
Lemma 3 (s-t-Pfade im Hilfsnetzwerk). Existiert ein s-t-Pfad P im Hilfsnetzwerk ohne
künstliche Kanten, so sind die Kosten von P günstiger als die Kosten jeder künstlichen
Kante und es gilt
c(P ) < cheaij ∀ eaij ∈ E a .
Insbesondere ist dann jeder s-t-Pfad ohne künstliche Kanten günstiger als ein Pfad mit
künstlichen Kanten [KV08, Seite 239].
Beweis. Da P ein Pfad ist, kann ein Knoten in P höchsten einmal vorkommen. Im Pfad
gibt es demnach weniger Knoten als in der gesamten Knotenmenge V . Seien V (P ) die
Knoten und E(P ) die Kanten im Pfad P . Dann gilt
|V (P )| ≤ |V | und
|E(P )| = |V (P )| − 1,
weil P ein Pfad war und eine Abfolge von eindeutigen Knoten und Kanten darstellt. Für
die Kosten des Pfades folgt dann mit der Annahme 2, dass alle Kosten cij ≥ 0 positiv sind
c(P ) =
X
cij
eij ∈P
≤ |E(P )| · max(cij : eij ∈ P )
= (|V (P )| − 1) · cmax
< |V (P )| · cmax
≤ |V | · cmax = cheaij
eaij ∈ E a .
41
3 Der Netzwerk Simplex Algorithmus
Der Algorithmus optimiert eine zulässige Baumstruktur auf einem Hilfsnetzwerk und erstellt daraus die Lösung für das ursprüngliche Problem [Jun04, Seite 331]. Da eine zulässige
Baumstruktur für das Hilfsnetzwerk existiert, wird es unter allen möglichen Lösungen auch
eine optimale Lösung geben. Nun kann es sein, dass das ursprüngliche Problem eventuell
gar nicht lösbar war, weil zum Beispiel einige Senken durch keine Quellen erreichbar waren
und im Hilfsnetzwerk nur mit den künstlichen Kanten versorgt wurden.
Lemma 4 (Lösbarkeit im Hilfsnetzwerk). Sei N h das Hilfsnetzwerk im Netzwerk N .
Dann existiert eine optimale Lösung xh im Hilfsnetzwerk. Für xh gibt es dann folgende
zwei Alternativen:
1. Es existiert eine optimale Lösung im Netzwerk N , wenn alle künstlichen Kanten
keinen Fluss haben:
xheaij = 0 ∀ eaij ∈ E a .
2. Es existiert keine Lösung im Netzwerk N , wenn mindestens eine künstliche Kante
einen Fluss hat:
xheaij > 0 ∃ eaij ∈ E a .
[Jun04, Seite 328]
Beweis. Wir untersuchen beide Fälle separat.
1. Für das Netzwerk N bilden wir den Fluss xh auf einen Fluss x aus allen ursprünglichen Kanten ab. Dann ist x eine optimale Lösung im Netzwerk N . Denn gäbe es
eine günstigere Lösung x∗ für N mit
c(x∗ ) < c(x) = c(xh ),
so könnten wir den Fluss x∗ auch auf xh abbilden. Das wäre aber ein Widerspruch
zur Optimalität von xh .
2. Existiert ein positiver Fluss xeaij auf einer künstlichen Kante eaij , so können wir diesen
nicht auf unser ursprüngliches Netzwerk N abbilden. Entfernen wir die Kante aus
unserer Lösung, so folgt, dass im Residualnetzwerk für die Balancen bi = −xeaij und
bj = xeaij gilt. Nun müssen wir einen Pfad P von i nach j ohne künstliche Kanten um
xeaij Einheiten augmentieren, damit der neue resultierende Fluss auch im Netzwerk
N abgebildet werden kann. Würde so ein Pfad existieren, dann wäre aber xh nicht
optimal, weil nach Lemma 3 der Weg über den Pfad günstiger gewesen wäre.
42
3.3 Der Algorithmus
3.3 Der Algorithmus
In diesem Abschnitt wird gezeigt, wie der Netzwerk Simplex Algorithmus funktioniert.
Der Algorithmus erhält als Eingabe ein Netzwerk N = (G, b, u, c) und benutzt eine Baumstruktur zur Darstellung der Lösung. Statt des ursprünglichen Netzwerks betrachten wir
das Hilfsnetzwerk. Wird das Problem im Hilfsnetzwerk gelöst, kann anschließend mit der
Bedingung in Lemma 4 die Lösung auf das Netzwerk N abgebildet oder keine Lösbarkeit festgestellt werden. Als Ausgangslösung benutzen wir die zulässige Baumstruktur im
Hilfsnetzwerk. Um diese zu optimieren, widmen wir uns zunächst der Bestimmung eines
Potentials und der damit verbundenen reduzierten Kosten, wie in [AMO93, Seite 411].
Im Beispiel aus der Abbildung 3.4 haben wir bereits einen spannenden Baum (V, T ) für
das Hilfsnetzwerk gefunden. Dabei waren alle künstlichen Kante eaij aus E a im spannenden
Baum (V, T ) enthalten, die ursprünglichen Kanten eij aus E in L und U waren leer. Mit
dem Algorithmus 2 können wir ausgehend vom Wurzelknoten 1 = r ∈ V das Potential für
die Baumstruktur (T, L, U ) der Ausgangslösung im Hilfsnetzwerk berechnen.
2 −12
2
12
1
12
4
0
12
1
4
12
3
3 12
T im Hilfsnetzwerk mit Kosten cij
Knotenpotentiale πi
Abbildung 3.5: Berechnung der Knotenpotentiale
Nachdem wir das Potential berechnet haben, muss für eine optimale Baumstruktur noch
die Bedingung 3.2 und 3.3 vom Satz 6 erfüllt sein. Ist das der Fall, so ist der Fluss der
Baumstruktur optimal. Andernfalls müssen wir die Baumstruktur modifizieren und damit
den Fluss so lange anpassen, bis die Bedingungen erfüllt sind. Dafür suchen wir nach einer
verletzenden Kante, indem wir die reduzierten Kosten berechnen.
2
2
0
1
−21
15
0
4
−22
1
−10
0
3
Reduzierte Kosten cπij in T
4
3
3
Reduzierte Kosten cπij in L
Abbildung 3.6: Berechnung der reduzierten Kosten
Für die Baumstruktur im Hilfsnetzwerk war die Menge U am Anfang leer. Daher existieren auch keine reduzierten Kosten in U und wir betrachten nur die reduzierten Kosten in
43
3 Der Netzwerk Simplex Algorithmus
L. In der Abbildung 3.6 verletzten die Kanten e13 , e23 und e24 die Optimalitätsbedingung
3.2, weil die Kanten in L enthalten sind und über negative reduzierten Kosten verfügen.
Wir sind nun in der Lage, ausgehend von einem Netzwerk für das Minimum Cost Flow
Problem eine Ausgangslösung als Baumstruktur (T, L, U ) zu konstruieren. Im Algorithmus
wird iterativ eine Baumstruktur optimiert, bis keine verletzenden Kanten mehr existieren
und der dazugehörende Fluss optimal ist [AMO93, Seite 415]. Für eine Baumstruktur sind
wir in der Lage mit den Algorithmen 1 und 2 den Fluss und das Potential der Baumstruktur
zu berechnen. Der Fluss erfüllt dabei die Bedingung der Kapazitätseinhaltung und die
Baumstruktur ist zulässig. Das heißt, dass die gesamte Nachfrage mit dem Angebot durch
den Fluss x beliefert wird. Diese Bedingung wird im Algorithmus durchgehend aufrecht
erhalten [AMO93, Seite 420]. Existiert eine verletzende Kante, so ist der Fluss x noch nicht
optimal und muss weiter angepasst werden. Da der Algorithmus auf dem Hilfsnetzwerk
arbeitet, kann mit dem Lemma 4 die Lösung für das Ausgangsnetzwerk bestimmt werden.
Algorithmus 3 : Netzwerk Simplex Algorithmus [AMO93, Seite 415]
Eingabe : Netzwerk N für ein Minimum Cost Flow Problem
Ausgabe : Optimale Lösung x oder feststellen, dass keine Lösung existiert
7
Konstruktion eines Hilfsnetzwerks und der Ausgangslösung
Berechnung des Potentials und der reduzierten Kosten
while Es existiert eine verletzende Kante do
Verletzende Kante bestimmen und zu T hinzufügen
Kreis C in (V, T ) bestimmen und um γ(C) Einheiten augmentieren
Eine beschränkte Kante aus C von T entfernen
Baumstruktur, Fluss und Potential aktualisieren
8
Abbildung der Lösung auf N oder feststellen, dass keine Lösung existiert
1
2
3
4
5
6
Definition 37 (Iteration im Netzwerk Simplex Algorithmus). Die Ausführung der Zeilen
3 bis 7 beschreiben eine Iteration im Netzwerk Simplex Algorithmus [AMO93, Seite 415].
Eine Iteration heißt
nicht degeneriert, wenn γ(C) > 0
und degeneriert , wenn γ(C) = 0
[AMO93, Seite 420].
Nachdem wir den Algorithmus eingeführt haben, können wir weitere Aussagen über eine
Iteration treffen.
Lemma 5 (Kreis in einer Iteration). Der Kreis C ist in einer Iteration des Netzwerk
Simplex Algorithmus eindeutig [AMO93, Seite 418].
Beweis. Haben wir in einer Iteration eine verletzende Kante ek` gefunden, so können wir
diese dem spannenden Baum (V, T ) hinzufügen. Dadurch ist (V, T ∪ ek` ) aber kein Baum
44
3.3 Der Algorithmus
mehr, da (V, T ) ein spannender Baum mit n − 1 Kanten war und nun n Kanten besitzt.
Daraus folgt, dass in (V, T ∪ ek` ) ein Kreis C existiert. Ist r der Wurzelknoten, so sind der
r-k-Pfad Prk und r-`-Pfad Pr` im spannenden Baum eindeutig. Haben Prk und Pr` keine
gemeinsamen Kanten, so besteht der Kreis aus den Kanten der Pfade und der verletzende
Kante. Sollten die Pfade jedoch gemeinsame Kanten besitzen, bildet die verletzende Kante
mit den nicht gemeinsamen Kanten der Pfade einen Kreis. Insgesamt ist dann der Kreis
mit
C = (ek` ∪ Prk ∪ Pr` ) \ (Prk ∩ Pr` )
eindeutig bestimmt.
Die Ausgangslösung beschreibt eine Baumstruktur im Hilfsnetzwerk. Der Fluss der
Baumstruktur ist ein b-Fluss. Im Algorithmus wird ausgehend von der Ausgangslösung
in jeder Iteration der Fluss aktualisiert. Wir können nun zeigen, dass nach jeder Iteration
der Fluss wieder ein b-Fluss ist und somit die resultierende Baumstruktur zulässig war.
Satz 9 (Baumstrukturen im Netzwerk Simplex Algorithmus). Betrachten wir im Netzwerk eine zulässige Baumstruktur, dann ist der Fluss der Baumstruktur ein b-Fluss. Nach
einer Iteration ist der Fluss der Baumstruktur wieder ein b-Fluss. Entsprechend bleibt die
Baumstruktur zulässig [AMO93, Seite 418].
Beweis. Ist ek` eine verletzende Kante in L oder U , so kann der Kreis in einer Iteration
nur in eine Richtung augmentiert werden. Das liegt daran, dass für eine Kante in L der
Fluss leer ist und die Kante im Residualnetzwerk keine Rückwärtskante besitzt. Analog
besitzt eine Kante in U im Residualnetzwerk keine Vorwärtskante. Wenn wir den Kreis im
Residualnetzwerk um γ(C) augmentieren, wird mindestens eine Kante epq in C beschränkt.
Insbesondere entsteht dann wieder ein b-Fluss, weil durch einen augmentierenden Kreis
die Balancen unverändert bleiben und mit γ(C) nur die Restkapazitäten genutzt werden. Dadurch erfüllt der resultierende Fluss die Kapazitätseinhaltung und wie x auch die
Flusserhaltung.
Je nachdem ob die beschränkte Kante epq im Residualnetzwerk eine Vorwärtskante oder
Rückwärtskante war, wird der Fluss xpq entweder leer oder gesättigt sein. Ist der Fluss xpq
leer, können wir die Kante epq von der Menge T ∪ ek` nach L überführen und andernfalls
0
0
0
nach U . Dadurch erhalten wir eine neue Baumstruktur (T , L , U ). Bezüglich des Flusses
xpq auf der beschränkten Kante erhalten wir folgende Kantenmengen:
xpq = 0
0
T = (T ∪ ek` ) \ epq
0
L = L \ ek` ∪ epq
0
U =U
xpq = upq
0
T = (T ∪ ek` ) \ epq
0
L = L \ ek`
0
U = U ∪ epq
45
3 Der Netzwerk Simplex Algorithmus
Satz 10 (Nicht degenerierte Iteration). Eine nicht degenerierte Iteration reduziert im
Netzwerk Simplex Algorithmus die Gesamtkosten vom Fluss der Baumstruktur [AMO93,
Seite 420].
Beweis. Sei x der Fluss der Baumstruktur, ek` eine verletzende Kante und C ein Kreis
in (V, T ∪ ek` ). Dann sind die reduzierten Kosten cπk` der Kante ek` negativ, wenn ek`
in L war und positiv, wenn ek` in U war. Wir können in beiden Fällen den Kreis mit
einem Fluss xC im Residualnetzwerk um positive γ(C) Einheiten augmentieren. Aus der
Gleichung 2.4 wissen wir, dass die Kosten und reduzierten Kosten für Kreise identisch
sind. Im Kreis sind alle Kanten außer ek` in T enthalten und die reduzierten Kosten
sind gleich 0. Die Kosten für den Kreis sind dann nur abhängig von den reduzierten
Kosten der verletzenden Kante. Wenn ek` in L ist, wird der Fluss auf der Vorwärtskante
von ek` augmentiert und für ek` in U auf der Rückwärtskante. Auf Vorwärtskanten sind
die Kosten im Residualnetzwerk identisch mit den Kosten im Ausgangsnetzwerk und der
Fluss nimmt zu, während auf Rückwärtskanten der Fluss abnimmt und die Kosten den
negativen Wert aus dem Ausgangsnetzwerk besitzen. Für die Kosten c(xC ) eines Flusses
xC im Residualnetzwerk gilt dann:
π
c(xC ) = cπ (xC ) = xC
k` · ck`
Betrachten wir den Fall, dass die verletzende Kante in L ist, folgt
π
π
c(xC ) = xC
k` ·ck` = γ(C) · ck` < 0
|{z}
|{z}
<0
=γ(C)
und für den Fall einer verletzenden Kante in U ist
π
π
xC
k` ·ck` = −γ(C) · ck` < 0.
|{z}
|{z}
c(xC ) =
>0
=−γ(C)
In beiden Fällen sind die Kosten des Kreises negativ. Ist x der Fluss der Baumstruktur
0
vor der Iteration, dann resultiert aus xC und x der Fluss x nach einer Iteration.
0
x = x ⊕ xC
0
c(x ) = c(x) + c(xC ) < c(x)
| {z }
<0
Insgesamt reduzieren sich dadurch nach einer nicht degenerierten Iteration die Gesamtkosten des Flusses der Baumstruktur.
Im Gegensatz zu einer nicht degenerierten Iteration verändern sich in einer degenerierten Iteration nicht die Gesamtkosten, weil γ(C) gleich 0 ist. In diesem Fall muss im
Kreis bereits eine beschränkte Kante existieren, die im Residualnetzwerk nur entgegengesetzt der Richtung der verletzenden Kante augmentiert werden kann. Andererseits existiert
46
3.3 Der Algorithmus
in degenerierten Baumstrukturen für jede Vorwärtskante auch eine Rückwärtskante und
umgekehrt. Daher ist für eine degenerierte Baumstruktur auch die Iteration degeneriert
[AMO93, Seite 418]. Weiterhin kann auch der Fall eintreten, dass in einer nicht degenerierten Baumstruktur die Iteration degeneriert ist, weil der Kreis in eine Richtung augmentiert
werden kann.
Um eine Iteration mit fünf Schritten zu veranschaulichen, werden wir uns erneut dem
Beispiel aus Abbildung 3.3 widmen. Dazu hatten wir eine Ausgangslösung in Form einer
Baumstruktur (T, L, U ) im Hilfsnetzwerk erstellt und den dazugehörenden Fluss x und
spannenden Baum (V, T ) in der Abbildung 3.5 dargestellt. Die Baumstruktur verfügte
über mehrere verletzende Kanten, wie wir in Abbildung 3.6 sehen können. Wir werden
nun eine Iteration ausführen, indem wir für den ersten Schritt in Zeile 4 die verletzende
Kante e13 in L auswählen. Anschließend können wir die Kante e13 dem spannenden Baum
(V, T ) hinzufügen und einen Kreis C im Residualnetzwerk des neuen Graphen (V, T ∪ e13 )
lokalisieren.
2
2
ea21
1
ea14
1
4
1
4
ea13
4
2
3
e13
3
4
Der Graph (V, T ∪ e13 )
Residualnetzwerk mit Kapazitäten
Abbildung 3.7: Verletzende Kante zum spannenden Baum hinzufügen
In der Abbildung 3.7 können wir nun einen Kreis C zwischen den Knoten 1 und 3
erkennen. Der Kreis C besteht aus den Kanten ea13 und e13 . Als nächstes können wir
den Kreis mit einem Fluss xC um γ(C) = 2 Einheiten augmentieren, da die Kanten im
Residualnetzwerk alle über einen Restkapazität von 2 verfügen. Nach der Augmentierung
wird im Kreis C mindestens eine Kante im Residualnetzwerk beschränkt sein.
ea13 (0, 2)
2
0
xea = 4
1
0
14
x13 = 2
3
0
Fluss x = x ⊕ xC
4
1
3
e13 (2, 4)
Fluss und Kapazitäten (xij , uij ) im
Kreis C
Abbildung 3.8: Augmentierung vom Kreis
Wie aus der Abbildung 3.8 hervorgeht, ist die Kante ea13 im Kreis C beschränkt, weil der
Fluss auf der Kante leer ist. Diese Kante muss also in die Menge L überführt werden. Wir
können die Kante ea13 also aus dem Graphen (V, T ∪ e13 ) entfernen. Als letztes müssen wir
47
3 Der Netzwerk Simplex Algorithmus
in einer Iteration die Baumstruktur, den Fluss und das Potential aktualisieren. Der neue
0
Fluss x ist bereits in der Abbildung 3.8 zu sehen und hat Gesamtkosten in Höhe von 52.
In der Iteration haben wir genau 20 Kosten eingespart, da die reduzierten Kosten für die
verletzende Kante −10 betrugen und der Kreis um 2 Einheiten augmentiert wurde. Die
0
0
0
aktualisierte Baumstruktur (T , L , U ) besteht aus den Kantenmengen
0
T = {ea12 , e13 , ea14 } = (T ∪ e13 ) \ ea13 ,
0
L = {e12 , ea13 , e23 , e24 , e34 } = (L \ e13 ) ∪ ea13 und
0
U = ∅ = U.
0
0
0
Für die resultierende Baumstruktur (T , L , U ) können wir nun das Potential und die
damit verbundenen reduzierten Kosten berechnen.
2 −12
2
0
12
1
4
−21
15
−12
1
−7
10
3
3 2
Potential π der Baumstruktur
4
0
Reduzierte Kosten cπij in L
Abbildung 3.9: Aktualisierung der Baumstruktur
Damit haben wir eine Iteration beendet und im Algorithmus wird nun in der neuen
Baumstruktur erneut nach einer verletzenden Kante gesucht. In unserem Beispiel ist die
0
0
Menge U leer, daher brauchen wir nur in der Menge L nach einer verletzenden Kante zu
suchen. In der Abbildung 3.9 können wir sehen, dass erneut verletzende Kanten e23 , e24
und e34 in L existieren.
3.4 Terminierung
Der vorgestellte Algorithmus berechnet für ein Minimum Cost Flow Problem eine optimale
Lösung. In jeder degenerierten Iteration können die Kosten für den b-Fluss des Problems
gesenkt werden. Gibt es in der Baumstruktur keine verletzende Kante, ist das Optimum
für das Hilfsnetzwerk gefunden und wir können die Lösung auf das ursprüngliche Problem
abbilden oder feststellen, dass keine Lösung existiert. Betrachten wir den Fall, dass immer
degenerierte Iterationen aufeinander folgen, werden die Gesamtkosten so lange reduziert,
bis irgendwann das Minimum erreicht ist. Nun ist nicht jede Iteration degeneriert. Bei
nicht degenerierten Iterationen kann sich zwar die Baumstruktur verändern, in dem eine
verletzende Kante in den spannenden Baum aufgenommen wird und eine andere Kante
den spannenden Baum verlässt, aber die Gesamtkosten werden dadurch nicht gesenkt. Im
schlimmsten Fall können nur nicht degenerierte Iterationen aufeinander folgen, so dass der
48
3.4 Terminierung
Algorithmus gar nicht terminiert [AMO93, Seite 420]. Da nur endlich viele Baumstrukturen existieren, werden in diesem Fall einige Baumstrukturen wiederkehrend in einer
Iteration behandelt. Der Algorithmus kreiselt und terminiert nicht. Könnte man garantieren, dass nach einem bestimmten Abstand von nicht degenerierten Iterationen immer
eine degenerierte Iteration folgt, würde der Algorithmus immer terminieren. Dann könnte
man nämlich auch garantieren, dass nach einer Folge von Iterationen die Gesamtkosten
echt abnehmen, bis das Minimum erreicht und die Lösung optimal ist [Jun04, Seite 332].
Wie wir aus Satz 8 wissen, bleiben zulässige Baumstrukturen im Algorithmus nach jeder
Iteration zulässig. Mit einer weiteren Eigenschaft der Baumstrukturen können wir zeigen,
dass eine Baumstruktur im Algorithmus nur einmal in einer Iteration vorkommen kann
und somit der Algorithmus nicht kreiselt [AMO93, Seite 421].
Definition 38 (Kanten im spannenden Baum). Ist r ein Wurzelknoten für den spannenden Baum (V, T ), so heißt eine Kante eij in T
Abwärtskante, wenn hoehe(i) < hoehe(j)
und Aufwärtskante, wenn hoehe(i) > hoehe(j).
Stellen wir uns den spannenden Baum vom Wurzelknoten nach unten hängend vor, so zeigt
eine Abwärtskante nach unten und führt vom Wurzelknoten weg, während eine Aufwärtskante nach oben zeigt und zum Wurzelknoten führt [AMO93, Seite 421].
Definition 39 (Stark zulässige Baumstruktur). Eine Baumstruktur heißt stark zulässig,
wenn im spannenden Baum (V, T ) jede Abwärtskante nicht leer und jede Aufwärtskante
nicht gesättigt ist. Für eine stark zulässige Baumstruktur gilt
eij Abwärtskante, dann 0 < xij ≤ uij
und eij Aufwärtskante, dann 0 ≤ xij < uij
[KV08, Seite 238].
Satz 11 (Restkapazitäten in stark zulässigen Baumstrukturen). Betrachten wir in einer
stark zulässigen Baumstruktur einen beliebigen i-r-Pfad von einem Knoten i zum Wurzelknoten r im spannenden Baum (V, T ), so kann der Pfad mit einer positiven Einheit γ(P )
augmentiert werden. Kann man umgekehrt jeden i-r-Pfad um positive Einheiten augmentieren, ist die Baumstruktur stark zulässig [AMO93, 422].
Beweis. Der i-r-Pfad ist im spannenden Baum eindeutig. Für eine Abwärtskante existiert
im Residualnetzwerk eine Rückwärtskante mit positiver Restkapazität. Eine Aufwärtskante ist im Pfad nicht gesättigt und verfügt ebenfalls über Restkapazitäten. Somit kann der
i-r-Pfad mit der kleinsten positiven Restkapazität γ(P ) augmentiert werden. Umgekehrt
kann man jeden i-r-Pfad nur augmentieren, wenn jede Aufwärtskante nicht gesättigt ist
und eine Abwärtskante eine Rückwärtskante mit positiver Restkapazität besitzt.
49
3 Der Netzwerk Simplex Algorithmus
Im Algorithmus wird in Zeile 6 eine beschränkte Kante gewählt, die in der Baumstruktur zur Menge L oder U überführt wird. Stark zulässige Baumstrukturen bleiben im
Algorithmus stark zulässig, wenn man die beschränkte Kante im Kreis geschickt wählt.
Definition 40 (Gipfelknoten im Kreis). Durch Hinzufügen einer verletzenden Kante ek`
entsteht in einer Iteration im Algorithmus ein Kreis. Haben der k-r-Pfad Pkr und `-rPfad P`r im spannenden Baum keine gemeinsamen Kanten, dann ist der Wurzelknoten der
einzige Knoten, der in beiden Pfaden enthalten ist. Ansonsten müssen gemeinsame Kanten
auf einem Pfad zum Wurzelknoten liegen, weil Knoten und Kanten in Pfaden eindeutig
sind. Sei in beiden Fällen Par der a-r-Pfad, der die gemeinsamen Kanten beschreibt. Im
ersten Fall besteht Par nur aus dem Wurzelknoten. Für den Kreis gilt dann:
Par = Pkr ∩ P`r
Pka = Pkr \ Par
P`a = P`r \ Par
C = ek` ∪ P`a ∪ Pka
Der Knoten a heißt dann bezüglich des Kreises Gipfelknoten [AMO93, Seite 418].
Satz 12 (Wahl der beschränkten Kante). Sei in einer Iteration die Baumstruktur stark
zulässig. Betrachte bei der Augmentierung des Kreises ausgehend vom Gipfelknoten die
letzte gesättigte Kante im Residualnetzwerk. Entfernt man diese beschränkte Kante und
fügt sie der Menge L oder U zu, so bleibt die Baumstruktur nach einer Iteration wieder
stark zulässig [Jun04, Seite 333].
Beweis. Sei (T, L, U ) die stark zulässige Baumstruktur am Anfang der Iteration und r der
Wurzelknoten. Durch Hinzufügen einer verletzenden Kante ek` nach T wird ein eindeutiger
Kreis C gebildet. Sei a der Gipfelknoten im Kreis. Da nur der Kreis augmentiert wird, ist
der a-r-Pfad Par auch nach einer Iteration in der Baumstruktur enthalten. Entsprechend
ist für den Pfad Par nichts zu zeigen, da sich der Fluss und somit die Restkapazitäten auf
den Kanten im Pfad nicht ändern. Insgesamt ändern sich für alle Kanten aus T , die nicht
im Kreis enthalten sind, der Fluss und die Restkapazitäten nicht. Wir müssen also nur
den Kreis betrachten.
Wir sortieren die Menge im Kreis C so um, dass der Kreis mit dem Gipfelknoten beginnt und in Richtung der Augmentierung verläuft. Für eine verletzende Kante in L ist
die Richtung des Kreises äquivalent der Richtung der verletzenden Kante. Sollte eine
verletzende Kante in U ausgewählt worden sein, muss der Kreis entgegengesetzt der Richtung der verletzenden Kante augmentiert werden, da im Residualnetzwerk dann nur die
Rückwärtskante existiert.
Sei nun epq die letzte im Residualnetzwerk gesättigte Kante in C. Zu beachten ist,
dass wir keine gewöhnliche beschränkte Kante betrachten. Existiert nämlich im Kreis eine
beschränkte Kante mit einem leeren Fluss, so wird die Kante im Residualnetzwerk nur
50
3.4 Terminierung
gesättigt, wenn die ganze Kapazität ausgeschöpft wird und ansonsten nicht. Entsprechend
wird eine beschränkte Kante, die vom Fluss der Baumstruktur gesättigt ist, im Residualnetzwerk nur gesättigt, wenn die Kapazität der Rückwärtskante ausgeschöpft wird. Da
wir den Kreis im Residualnetzwerk um γ(C) Einheiten augmentieren, wird auf jeden Fall
eine Kante im Residualnetzwerk gesättigt.
Entfernen wir nun die Kante epq aus dem Kreis, entstehen zwei neue Pfade mit dem p-aPfad Ppa und q-a-Pfad Pqa . Diese Pfade existieren dann auch in der neuen Baumstruktur.
Damit die neue Baumstruktur stark zulässig ist, müssen wir zeigen, dass die Kanten in
den Pfaden Ppa und Pqa die Bedingung der stark zulässigen Baumstruktur erfüllen.
Der Pfad Pqa besitzt keine gesättigte Kante im Residualnetzwerk, da sonst im Kreis C
die Kante epq nicht die letzte gesättigte Kante im Residualnetzwerk sein kann. Daher kann
man den Pfad Pqa um positive Einheiten augmentieren und die Kanten in Pqa erfüllen die
Bedingung der stark zulässigen Baumstruktur.
Als letztes betrachten wir den Pfad Ppa . Hier müssen wir zwischen zwei Fällen unterscheiden. Wenn die Iteration nicht degeneriert war, dann haben wir den entgegengesetzten
a-p-Pfad Pap zuvor mit positiven γ(C) Einheiten augmentiert. Entsprechend existieren im
Pfad Ppa mindestens Restkapazitäten in der Höhe von γ(C) und die Kanten erfüllen die
Bedingung der stark zulässigen Baumstruktur. War die Iteration hingegen degeneriert, so
kann zunächst der Pfad Ppa nicht die verletzende Kante ek` enthalten. Die verletzende
Kante würde im Pfad Ppa eine Abwärtskante mit leerem Fluss darstellen. Da am Anfang
der Iteration die Baumstruktur stark zulässig war, konnte man jeden beliebigen Pfad im
spannenden Baum um positive Einheiten augmentieren. Da auch der `-r-Pfad P`r um positive Einheiten augmentiert werden konnte, kann in P`r keine Kante gesättigt sein, weil
in einer degenerierten Iteration γ(C) gleich 0 ist. Die gesättigte Kante muss im Kreis also
vor der verletzenden Kante existieren. Nun konnte man auch vor der Iteration aus jedem
Knoten im Pfad Ppa einen positiven Fluss zum Wurzelknoten senden und da γ(C) gleich
0 war, ist das auch nach einer Iteration möglich.
Insgesamt ist damit gezeigt, dass durch die beschriebene Wahl der beschränkten Kanten
eine stark zulässige Baumstruktur nach einer Iteration erhalten bleibt.
Lemma 6 (Baumstruktur der Ausgangslösung). Die Baumstruktur der Ausgangslösung
ist stark zulässig [KV08, Seite 239].
Beweis. Der spannenden Baum der Ausgangslösung bestand nur aus künstlichen Kanten,
die mit dem Wurzelknoten r inzident waren. Dabei waren alle Abwärtskanten gesättigt
und Aufwärtskanten nicht gesättigt. Daraus folgt, dass die Baumstruktur stark zulässig
ist.
Beginnen wir mit einer stark zulässigen Ausgangslösung, so kann durch die Wahl der
beschränkten Kante nach Satz 12 in jeder Iteration die Eigenschaft aufrecht erhalten
werden. Als nächstes betrachten wir das Potential nach einer Iteration.
51
3 Der Netzwerk Simplex Algorithmus
Satz 13 (Potential nach einer Iteration). Sei ek` eine verletzende Kante und epq eine
beschränkte Kante für eine Iteration mit stark zulässigen Baumstrukturen. Ist (T, L, U ) die
Baumstruktur vor der Iteration, so ist (V, T ) ein spannender Baum im Graphen. Entfernen
wir nun zunächst die beschränkte Kante aus diesem spannenden Baum, so zerfällt der
Baum in zwei neue Teilbäume T1 und T2 . Sei T1 der Teilbaum, in dem der Wurzelknoten
0
enthalten ist. Ist π das Potential vor einer Iteration und π das Potential der Baumstruktur
nach einer Iteration, so gilt:



π , wenn i ∈ V (T1 )

 i
0
πi = πi + cπk` , wenn i ∈ V (T2 ) und k ∈ V (T1 )



π − cπ , wenn i ∈ V (T ) und k ∈ V (T )
i
2
2
k`
[Jun04, Seite 335].
0
Beweis. Sei T die Kantenmenge für den spannenden Baum nach einer Iteration. Dann
0
besteht T aus der der Menge T mit der verletzenden Kante ek` und ohne die beschränkte
Kante epq .
T1
r
v1
k
p
T2
q
v2
`
Abbildung 3.10: Teilbäume von (V, T )
0
Der Teilbaum T1 bleibt in der Kantenmenge T enthalten und der Teilbaum T2 wird
nun durch die verletzende Kante ek` mit dem Wurzelknoten verbunden. Betrachten wir
0
die Pfade im Teilbaum T1 , so sind diese sowohl in T als auch in T enthalten, wodurch die
Potentiale dieser Knoten übereinstimmen müssen. Mit dem eindeutigen Potential sind die
reduzierten Kosten für die neue Baumstruktur nämlich durch
cπij = cij + πi − πj = 0 ∀ eij ∈ T
0
definiert. Da die verletzende Kante den Teilbaum T2 mit dem Teilbaum T1 verbindet,
unterscheiden wir zwei Fälle. Für den ersten Fall sei der Knoten k in T1 und ` in T2 . Dann
52
3.4 Terminierung
bleibt das Potential von k unverändert und für das Potential von ` gilt
0
π` = πk + ck` = πk + ck` + π` − π` = π` + cπk` .
(3.9)
0
Da sich die internen Pfade in T2 in der neuen Baumstruktur T nicht ändern, sind alle
Knoten i in T2 wie in der Gleichung 3.9 definiert. Betrachten wir nun den umgekehrten
Fall, dass der Knoten k sich in T2 befindet und ` in T1 . Dann verändert sich das Potential
von ` nicht und für das Potential von k gilt
0
πk = π` − ck` = π` − ck` + πk − πk = πk − cπk` .
(3.10)
Auch hier bleiben die Pfade innerhalb des Teilbaums T2 unverändert und die Gleichung
3.10 lässt sich auf jeden Knoten in T2 anwenden.
Lemma 7 (Daten bleiben ganzzahlig). Nach Annahme 1 sind alle Daten am Anfang
ganzzahlig. Nach jeder Iterationen bleiben die Daten wieder ganzzahlig [KV08, Seite 238].
Beweis. In jeder Iteration wird ein Kreis C mit γ(C) Einheiten augmentiert. Da die Daten am Anfang ganzzahlig waren, ist auch γ(C) ganzzahlig. Demnach bleiben auch die
Balancen und der Fluss der Baumstruktur ganzzahlig. Ferner ist nach Satz 13 auch das
Potential und damit auch die reduzierten Kosten nach jeder Iteration ganzzahlig.
Satz 14 (Der Algorithmus terminiert). Der Netzwerk Simplex Algorithmus terminiert mit
der Wahl der beschränkten Kante wie in Satz 12 [Jun04, Seite 335].
Beweis. Jede nicht degenerierte Iteration reduziert die Gesamtkosten vom Fluss der Baumstruktur. Da das Problem ein Minimum besitzt und die Daten nach 7 ganzzahlig sind,
können nur endlich viele nicht degenerierte Iterationen existieren. Wir werden nun zeigen,
dass für den Algorithmus auch endlich viele degenerierte Iterationen existieren. Dazu betrachten wir die zwei Fälle, dass die verletzende Kante ek` für eine degenerierte Iteration
entweder in der Menge L oder U ist. Mit epq bezeichnen wir die beschränkte Kante wie in
Satz 12.
Sei die verletzende Kante in der Menge L. Demnach existiert im Residualnetzwerk
nur die Vorwärtskante der verletzenden Kante und der Kreis wird in der Richtung von
ek` augmentiert. Die beschränkte Kante epq muss dann in der Orientierung von C vor
der verletzende Kante vorkommen. Demnach liegt der Knoten k nach dem Satz 13 im
Teilbaum T1 und für das Potential eines beliebigen Knotens i in T2 gilt
0
πi = πi − cπk` > πi .
|{z}
<0
Ist die verletzende Kante in der Menge U , so wird der Kreis entgegengesetzt der Richtung
von ek` augmentiert. Entsprechend liegt der Knoten k nach dem Satz 13 im Teilbaum T2
53
3 Der Netzwerk Simplex Algorithmus
und für das Potential eines beliebigen Knotens i in T2 gilt
0
πi = πi + cπk` > πi .
|{z}
>0
Das Potential für einen Knoten im Teilbaum T1 verändert sich nicht. Summieren wir
die Potentiale jedes Knotens, so nimmt bei einer degenerierten Iteration die Summe um
mindestens 1 zu. Das Potential des Wurzelknotens r bleibt dabei per Definition immer bei
0. Demnach kann für einen Knoten kein Potential größer als
n · max(|cπij |, eij ∈ E)
sein, weil insgesamt n Knoten existieren und durch das Potential eines Knotens die reduzierten Kosten definiert werden. Die Summe der Potentiale sind dann durch
X
πi < n · n · max(|cπij |) = n2 · max(|cπij |)
i∈V
nach oben beschränkt. Somit folgt nach endlich vielen degenerierten Iterationen immer
eine nicht degenerierte Iteration und die Gesamtkosten des Flusses der Baumstruktur
werden reduziert. Dadurch wird irgendwann das Minimum erreicht und der Algorithmus
terminiert.
3.5 Laufzeit
Die Laufzeit des Netzwerk Simplex Algorithmus variiert je nach Implementation und ist in
der Theorie nicht polynomiell [KV08, Seite 241]. Während im vorgestellten Algorithmus
für die Terminierung die Wahl der beschränkten Kante vorgegeben ist, kann die verletzende
Kante in einer Iteration auf eine ganz verschiedene Art und Weise ausgemacht werden.
Da in jeder nicht degenerierten Iteration die Gesamtkosten in Höhe des Produktes der
minimalen Restkapazität des Kreises und der reduzieren Kosten der verletzenden Kante
abnehmen, kann die verletzende Kante als die mit den betragsmäßig höchsten reduzierten
Kosten gewählt werden. Diese Wahl der verletzende Kanten wird nach George Dantzig als
Pivotstrategie von Dantzig bezeichnet [AMO93, Seite 416]. Statt alle reduzierten Kosten zu
vergleichen, kann man in einer Implementation des Algorithmus auch die Pivotstrategie der
ersten verletzenden Kante wählen [AMO93, Seite 417]. Auch die Pivotstrategie beeinflusst
erheblich die Laufzeit des Algorithmus.
Obwohl die Laufzeit des Algorithmus nicht polynomiell ist, sind die Ergebnisse aus der
Praxis nach Ahuja et al. exzellent [AMO93, Seite 451]. Tarjan konnte eine obere Schranke
mit
1
O(n 2 ·log n+O(1) )
Iteration finden [GTT90, Seite 144]. Weiterhin gab es bereits von Orlin, Plotkin und
54
3.5 Laufzeit
Tardos Bestrebungen zum Finden einer Implementierung, die in polynomieller Laufzeit
läuft. [KV08, Seite 241].
55
4 Der Cost Scaling Algorithmus
Der Cost Scaling Algorithmus (CSA) berechnet eine optimale Lösung für das Minimum
Cost Flow Problem, indem es die Optimalitätsbedingung des komplementären Schlupfs
ausnutzt. Dabei wird die Optimalitätsbedingung aufgeweicht und in jeder Iteration eine zulässige Lösung berechnet, die nicht notwendigerweise optimal ist. Die Bedingungen
des komplementären Schlupfs werden iterativ hergestellt. Ist die Bedingung des komplementären Schlupfs erfüllt, so ist die Lösung optimal. Wie der Netzwerk Simplex Algorithmus geht auch der CSA von einer Ausgangslösung aus [AMO93, Seite 362]. Der Algorithmus ist in der Literatur auch unter dem Namen Scaling Push Relabel Algorithmus
bekannt [Zlo10, Seite 59]. Dieser Name stammt von der Ähnlichkeit des CSA zum Push
Relabel Algorithmus, der Maximum Flow Probleme für Netzwerke löst.
4.1 Definitionen und Sätze
Im CSA werden die Bedingungen vom komplementärem Schlupf aus Satz 3 aufgeweicht
und für die Flüsse eine entsprechende Vorgabe gemacht.
Definition 41 (ε-Optimalität). Ein b-Fluss oder Pseudofluss x heißt ε-optimal für ein
ε größer oder gleich 0, wenn für ein Potential π und die damit verbundenen reduzierten
Kosten cπ folgende Bedingungen erfüllt sind:
xij = 0, wenn cπij > ε
xij = uij , wenn cπij < −ε
0 ≤ xij ≤ uij , wenn − ε ≤ cπij ≤ ε
[AMO93, Seite 363].
Ist ε gleich 0 ist, so ist die ε-Optimalität äquivalent mit dem komplementärem Schlupf.
Während die Bedingungen vom komplementärem Schlupf die Optimalität des Flusses garantieren, muss ein ε-optimaler Fluss nicht unbedingt optimal sein.
Lemma 8 (Reduzierte Kosten für ε-optimale Flüsse). Ein b-Fluss oder Pseudofluss x ist
genau dann ε-optimal, wenn alle Kanten im Residualnetzwerk reduzierte Kosten in Höhe
von mindestens −ε haben. Es gilt:
cπij ≥ −ε ∀ eij ∈ E(x) ⇐⇒ x ist ε-optimal
56
(4.1)
4.1 Definitionen und Sätze
[AMO93, Seite 363].
Beweis. Ist x ein ε-optimaler Fluss, so haben nach Definition der ε-Optimalität nur Kanten mit gesättigtem Fluss reduzierte Kosten kleiner als −ε. Da im Residualnetzwerk keine
gesättigten Kanten existieren, haben für ε-optimale Flüsse alle Kanten im Residualnetzwerk reduzierte Kosten in Höhe von mindestens −ε.
Wir betrachten nun einen beliebigen b-Fluss oder Pseudofluss x, für den alle Kanten im
Residualnetzwerk reduzierte Kosten in Höhe von mindestens −ε haben. Für Kanten im
Residualnetzwerk mit reduzierten Kosten kleiner als ε ist nichts zu zeigen, da sie einen
beliebigen Fluss innerhalb der Kapazitäten haben dürfen. Betrachten wir die Kanten mit
reduzierten Kosten größer als ε, so sind für nicht leere Flüsse auch die Rückwärtskanten
mit den negativen reduzierten Kosten im Residualnetzwerk vorhanden. Dann haben aber
nicht alle Kanten im Residualnetzwerk reduzierte Kosten in Höhe von mindestens −ε, also
müssen diese Kanten einen leeren Fluss haben. Entsprechend sind Kanten mit reduzierten
Kosten kleiner als −ε gesättigt, da diese Kanten nicht im Residualnetzwerk sind. Ihre im
Residualnetzwerk befindlichen Rückwärtskanten haben einen leeren Fluss.
Satz 15 (ε-optimale Flüsse). Für ein Minimum Cost Flow Problem ist jeder b-Fluss
ε-optimal, wenn ε ≥ cmax
1
und optimal, wenn ε <
n
[AMO93, Seite 363].
Beweis. Sei ein beliebiger b-Fluss gegeben und betrachte ein Potential, bei dem jeder
Knoten den Wert 0 hat. Dann sind die reduzierte Kosten mit den Kosten identisch und
alle Kosten sind im Residualnetzwerk größer als −cmax . Insbesondere erfüllt nach der
Definition der ε-Optimalität jeder Fluss der Kanten die Bedingungen und der Fluss ist
ε-optimal.
Wir betrachten nun einen b-Fluss mit ε kleiner als
1
n
für ein Potential π. Existiert im
Residualnetzwerk ein Kreis C, so gilt für die Gesamtkosten des Kreises
c(C) = cπ (C) =
X
(4.1)
cπij ≥ −ε · n > −1,
eij ∈C
da ε echt kleiner als
1
n
war. Mit der Annahme 1 über die Ganzzahligkeit der Kosten folgt,
dass kein Kreis mit negativen Kosten existiert. Aus dem Satz 1 von Klein wissen wir, dass
b-Flüsse ohne negative Kreise optimal sind.
Lemma 9 (ε-optimaler Pseudofluss). Sei x ein ε-optimaler b-Fluss für ein Potential π.
57
4 Der Cost Scaling Algorithmus
Dann entsteht aus x ein ε-optimaler Pseudofluss xp mit
xpij = uij , wenn cπij < 0
xpij = xij sonst.
Insbesondere ist der Pseudofluss auch ε-optimal mit ε gleich 0 [Gol97, Seite 4].
Beweis. Für den Pseudofluss xp sind alle Kanten mit negativen reduzierten Kosten
gesättigt. Für jede Kante eij im Residualnetzwerk gilt demnach
cπ ≥ 0
und es existieren keine negativen Kreise. Nach Lemma 9 ist der Fluss dann ε-optimal mit
ε gleich 0.
Der Algorithmus wird in jeder Iteration aus einem b-Fluss einen Pseudofluss generieren.
Da ein Pseudofluss nicht die Flusserhaltung erfüllen muss, können im Residualnetzwerk
Knoten mit echt positiven oder negativen Balancen vorhanden sein.
Definition 42 (Aktive Knoten). Besitz ein Knoten im Residualnetzwerk eine positive
Balance, so heißt der Knoten aktiv. Für einen aktiven Knoten i in V gilt:
bi (x) = bi +
X
eji ∈E
xji −
X
xij > 0
eij ∈E
[Gol97, Seite 3]. Der Knoten stellt dann im Residualnetzwerk eine Quelle dar.
Um einen b-Fluss zu generieren, muss das Angebot aus den aktiven Knoten wieder
abtransportiert werden. Dafür wählen wir eine mit dem aktiven Knoten inzidente Kante
aus, die über negative reduzierte Kosten und Restkapazitäten verfügt.
Definition 43 (Zulässige Kanten). Für einen Fluss und ein Potential heißt eine Kante
zulässig, wenn die Kante nicht gesättigt ist und über negative reduzierte Kosten verfügt.
Insbesondere existiert die Kante dann auch im Residualnetzwerk und verfügt über eine
positive Restkapazität [Gol97, Seite 3].
Betrachten wir nun einen aktiven Knoten, so können wir im Residualnetzwerk das Angebot mit einer Operation abtransportieren.
Definition 44 (Push). Sei x ein Pseudofluss im Netzwerk N = (G, b, u, c). Existiert ein
aktiver Knoten i in V , so heißt eine Operation auf dem Knoten Push, wenn eine zulässige
Kante eij in E(x) maximal augmentiert wird. Für den Fluss der zulässigen Kante gilt:
xij = max(bi (x), uij (x)).
58
4.1 Definitionen und Sätze
Die zulässige Kante wird im Residualnetzwerk entweder um einen Fluss der Größe des
Angebots des aktiven Knotens augmentiert oder vorher gesättigt. Für die Operationen
schreiben wir push(i) [Gol97, Seite 5].
Nach einer Push-Operation können zwei Fälle auftreten. Entweder wird durch den Fluss
auf der zulässigen Kante das gesamte Angebot im aktiven Knoten abtransportiert oder
nicht. Im letzteren Fall bleibt der Knoten weiterhin aktiv [Zlo10, Seite 77]. Wir können
zeigen, dass ein Push nicht die Bedingung der ε-Optimalität beeinträchtigt.
Satz 16 (Push-Operation). Ist ein ε-optimaler Pseudofluss gegeben und wird für einen aktiven Knoten ein Push ausgeführt, so bleibt der resultierende Pseudofluss ε-optimal [Zlo10,
Seite 77].
Beweis. Um zu zeigen, dass der resultierende Pseudofluss wieder ε-optimal ist, müssen
die Bedingungen der ε-Optimalität für alle Kanten im Residualnetzwerk gelten. Da sich
durch einen Push nicht das Potential und damit auch nicht die reduzierten Kosten ändern,
müssen wir nur neue Kanten im Residualnetzwerk betrachten. In einem Push wird eine
zulässige Kante entweder gesättigt oder der Fluss wird um das Angebot im aktiven Knoten
erhöht ohne gesättigt zu werden. Wird die zulässige Kante gesättigt, so wird die Kante
aus dem Residualnetzwerk entfernt und wir brauchen für sie nichts zu zeigen. Wenn der
Fluss auf der zulässigen Kante vorher leer war, kann durch einen Push die Rückwärtskante
im Residualnetzwerk aufgenommen werden. Die reduzierten Kosten der zulässigen Kante
waren negativ, aber mindestens −ε, da die Kante sonst nicht im Residualnetzwerk sein
kann. Für die Rückwärtskante gilt dann, dass die reduzierten Kosten positiv sind aber nicht
mehr als ε. Demnach gilt auch für die Rückwärtskante die Bedingung der ε-Optimalität
und der resultierende Pseudofluss bleibt ε-optimal.
Nun kann es durchaus vorkommen, dass für ein aktiven Knoten kein Push ausgeführt
werden kann, da keine inzidenten zulässigen Kanten existieren. In diesem Fall kann das
Angebot im aktiven Knoten nicht reduziert und entsprechend auch kein b-Fluss gebildet werden. Existieren jedoch andere inzidente Kanten mit genügend Restkapazitäten,
so könnte man das Angebot durch einen Fluss über diese Kante loswerden. Dann kann
man aber nicht mehr die ε-Optimalität des resultierenden Flusses garantieren. Reduziert
man hingegen das Potential im aktiven Knoten und berechnet neue reduzierte Kosten, so
können einige dieser Kanten zu zulässigen Kanten werden und wir könnten das Angebot
mit einem Fluss auf diesen Kanten reduzieren ohne die ε-Optimalität zu verletzen [Zlo10,
Seite 77].
Definition 45 (Relabel). Verfügt ein aktiver Knoten i in V keine ausgehende zulässige
Kante, so heißt eine Operation auf dem Knoten bezüglich positivem ε Relabel, wenn das
Potential von i durch
πi = max (πj − cij ) − ε
eij ∈E(x)
neu definiert wird und wir schreiben relabel(i) [Gol97, Seite 5].
59
4 Der Cost Scaling Algorithmus
Lemma 10 (Relabel erzeugt zulässige Kanten). Nach Ausführung von Relabel entsteht
mindestens eine mit dem aktiven Knoten inzidente zulässige Kante [Zlo10, Seite 77]. Weiterhin wird das Potential des aktiven Knotens reduziert [Jun04, Seite 307].
Beweis. Der aktive Knoten besitzt vor der Ausführung von Relabel über keine inzidenten
zulässigen Kanten. Demnach haben alle inzidenten Kanten positive reduzierte Kosten.
Bei der Ausführung von Relabel wird für eine Kante im Residualnetzwerk das Maximum
angenommen. Sei i der aktive Knoten und eim die Kante, für die das Maximum in Relabel
angenommen wird. Für das Potential des Knotens i gilt dann
πm − cim = max (πj − cij )
eij ∈E(x)
(4.2)
πi = πm − cim − ε .
0
Sei nun π das Potential vor der Operation, dann gilt
0
0
0
cπim = cim + πi − πm
0
0
0
⇔ πi = πm − cim + cπim .
Da sich das Potential im Knoten m nicht geändert hat, ist die Differenz zwischen dem
alten und neuen Potential des Knotens i gegeben mit
0
0
πi − πi = (πm − cim + cπim ) − (πm − cim − ε)
0
= cπim + ε
≥ ε > 0.
Das liegt daran, dass ε größer als 0 und die reduzierten Kosten der Kante eim nicht negativ
war, da man sonst eine zulässige Kante hätte. Demnach wird das Potential im Knoten i
mindestens um ε reduziert.
Betrachten wir die reduzierten Kosten mit dem neuen Potential vom Knoten i für die
Kante eim , so gilt
cπim = cim + πi − πm
= cim + πm − cim − ε − πm
= −ε
<0
und die Kante wird zulässig.
Satz 17 (Relabel-Operation). Ist ein ε-optimaler Pseudofluss gegeben und wird ein Relabel
ausgeführt, so bleibt der Pseudofluss ε-optimal [Zlo10, Seite 78].
60
4.2 Der Algorithmus
Beweis. Durch ein Relabel wird nur das Potential im aktiven Knoten geändert. Demnach
ändern sich nur die reduzierten Kosten der Kanten, die mit dem aktiven Knoten inzident
waren. Der resultierende Pseudofluss ist dann ε-optimal, wenn die Bedingungen der εOptimalität für diese Kanten gelten. Ist i der aktive Knoten, dann untersuchen wir die
Kanten in δ(i). Dazu betrachten wir gesondert die Fälle der ausgehenden und eingehenden
Kanten im Residualnetzwerk.
Ein Relabel wird nur ausgeführt, wenn der aktive Knoten über keine ausgehende nicht
gesättigte Kante mit negativen reduzierten Kosten verfügt, da sonst zulässige Kanten
existieren würden. Wir betrachten daher zunächst den ersten Fall mit allen ausgehenden Kanten im Residualnetzwerk. Im Residualnetzwerk existieren für den aktiven Knoten
nämlich nur nicht gesättigte ausgehende Kanten. Diese haben vor der Operation über nicht
negative reduzierte Kosten verfügt. Sei πi das Potential vom Knoten i nach der Operation
und eim die Kante, für die in der Operation das Maximum angenommen wird. Für diese
Kanten gilt dann
cπij = cij + πi − πj
∀ eij ∈ δ + (i) : xij < uij
= cij + πm − cim − ε − πj
(4.2)
= (cij − πj ) − (cim − πm ) −ε
|
{z
}
>0
≥ −ε.
Aus Lemma 10 wissen wir, dass das Potential im aktiven Knoten reduziert wird. Damit
erfüllen die Kanten dann die Bedingung der ε-Optimalität.
Während die reduzierten Kosten von ausgehenden Kanten reduziert wurden, werden
die reduzierten Kosten von eingehenden Kanten erhöht. Da der Fluss vor der Ausführung
von Relabel ε-optimal war, waren die reduzierten Kosten der eingehenden Kanten im
Residualnetzwerk nach Lemma 8 größer als −ε. Da für den zweiten Fall die reduzierten
Kosten der eingehenden Kanten nach Lemma 10 um mindestens ε erhöht werden, werden
die reduzierten Kosten größer oder gleich 0. Mit Lemma 8 ist dann der Fluss insgesamt
ε-optimal.
4.2 Der Algorithmus
Mit den eingeführten Operationen können wir den Algorithmus vollständig beschreiben.
Definition 46 (Iterationen im Cost Scaling Algorithmus). Der Algorithmus enthält zwei
ineinander geschachtelte while-Schleifen. Die Ausführung der äußeren while-Schleife zwischen den Zeilen 4 und 11 heißt eine Refine-Iteration und die Ausführung der inneren
while-Schleife zwischen den Zeilen 7 und 11 eine Discharge-Iteration. Während in der
Refine-Iteration der Wert von ε skaliert und somit verfeinert wird, wird durch Ausführungen von Discharge-Iterationen ein ε-optimaler b-Fluss gebildet. Die Discharge-Iteration
61
4 Der Cost Scaling Algorithmus
Algorithmus 4 : Cost Scaling Algorithmus [Gol97, Seite 4 und 5]
Eingabe : Netzwerk N für ein Minimum Cost Flow Problem
Ausgabe : Optimale Lösung x oder feststellen, dass keine Lösung existiert
1
2
3
4
5
6
7
8
9
10
11
ε := cmax
πi := 0 ∀ i ∈ V
Finden einer Ausgangslösung oder feststellen, dass keine Lösung existiert
while ε ≥ n1 do
ε := αε
Pseudofluss wie in Lemma 9 erstellen
while Es existiert ein aktiver Knoten i do
if Es existiert zulässige Kante in δ + (i) then
push(i)
else
relabel(i)
wird für einen aktiven Knoten so oft angewandt, bis der Knoten nicht mehr aktiv ist
[Gol97, Seite 5].
Der Algorithmus beginnt mit einer ε-optimalen Ausgangslösung für ε gleich cmax . Danach wird in jeder Refine-Iteration der Wert für ε durch Skalierung um einen Faktor reduziert und der Fluss durch Discharge-Iterationen so angepasst, dass er wieder ε-optimal
ist [AMO93, Seite 364]. Nachdem ε reduziert wird, generiert der Algorithmus zuerst wie
in Lemma 9 einen Pseudofluss und erstellt danach daraus einen b-Fluss. Da nach Annahme 4 das gesamte Angebot und die gesamte Nachfrage übereinstimmen, betrachten
wir im Residualnetzwerk nur aktive Knoten. Unter Berücksichtigung der Definition 41
der ε-Optimalität, wird das Angebot aus den aktiven Knoten schrittweise abtransportiert.
Haben wir irgendwann einen b-Fluss mit ε kleiner als
1
n
generiert, so ist der b-Fluss nach
Satz 15 optimal.
Wie der Netzwerk Simplex Algorithmus geht auch der Cost Scaling Algorithmus von
einer Ausgangslösung aus. Es muss noch gezeigt werden, dass nach jeder Refine-Iteration
ein b-Fluss gebildet wird. Dafür gibt es zwei Herangehensweisen. Während Zlotowski in
seiner Beschreibung des Cost Scaling Algorithmus als Ausgangslösung einen ε-optimalen
Pseudofluss oder b-Fluss verlangt [Zlo10, Seite 75], akzeptiert Goldberg in seiner Beschreibung nur b-Flüsse als Ausgangslösung [Gol97, Seite 4]. Einerseits kann man zeigen, dass
falls im Netzwerk ein b-Fluss existiert, dann auch in einer Iteration ein b-Fluss gebildet
wird [AMO93, Seite 366]. Andererseits ist es möglich, die Anzahl der notwendigen Operationen zum bilden eines b-Flusses in den Discharge-Iterationen nach oben abzuschätzen.
Braucht der Algorithmus mehr Operationen, so kann man feststellen, dass im Netzwerk
keine Lösung existiert [Zlo10, Seite 81].
Betrachten wir das Netzwerk N aus Abbildung 2.6, so können wir bereits einen Pseudofluss bilden und einige aktive Knoten und zulässige Kanten ausfindig machen. Als Ausgangslösung benutzen wir einen beliebigen b-Fluss x. Wir vernachlässigen zunächst, wie
62
4.2 Der Algorithmus
wir die Ausgangslösung gefunden haben. Mit ε gleich cmax ist der Fluss ε-optimal. In
unserem Fall ist der Fluss also 3-optimal.
0
0
2
6
(4; 3)
(2; 3)
0
4
1
(3; 2)
1
(4; 2)
2
−4
4
1
3
(4; 3)
0
4
2
3
3
3
−2
0
Netzwerk
b-Fluss im Netzwerk
Abbildung 4.1: Ausgangslösung
Die Ausgangslösung hat Gesamtkosten in Höhe von 34. Als nächstes betrachten wir das
Residualnetzwerk N (x). Das Potential sei wie im Algorithmus am Anfang für alle Knoten
gleich 0. Demnach sind die Kosten und reduzierten Kosten zunächst identisch. Aus der
Annahme 2 wissen wir, dass alle Kosten positiv sind. Existiert in der Ausgangslösung
keine kostenlose Kante mit Kosten gleich 0, so erzeugt der Fluss für jeder Kante im Residualnetzwerk eine Rückwärtskante mit negativen Kosten.
2
(4; −3)
(1; −3)
(1; 3)
(3; −2)
1
(2; 2)
(2; −2)
i
4
(uij (x); cij )
(1; 3)
3
(3; −3)
j
Abbildung 4.2: Residualnetzwerk
Nun können wir ausgehend vom Residualnetzwerk einen Pseudofluss bilden. Um einen
Pseudofluss zu bilden, werden alle Kanten mit negativen reduzierten Kosten gesättigt. In
unserem Fall wird die Ausgangslösung vollständig annulliert, da keine kostenlose Kante in
der Ausgangslösung existiert hat. Der Pseudofluss ist ein leerer Pseudofluss, in dem alle
Kanten einen Fluss von 0 haben. Damit sind alle ursprünglichen Quellen im Pseudofluss
aktive Knoten und das Netzwerk ist mit dem Residualnetzwerk identisch. Ist α gleich 2,
dann wird ε in einer Iteration zwischen den Zeilen 4 und 11 halbiert. Da wir mit einem
3-optimalen b-Fluss begonnen haben, wird ε in der ersten Iteration auf 1, 5 reduziert. Der
Pseudofluss ist nach Lemma 9 immer 0-optimal und insbesondere auch 1, 5-optimal. Da im
Netzwerk keine negativen Kosten existieren, gibt es auch keine zulässigen Kanten. Für den
aktiven Knoten 1 müssen wir demnach ein Relabel ausführen und das Potential anpassen.
Nach der Ausführung von relabel(1) bekommt das Potential im aktiven Knoten den neuen
63
4 Der Cost Scaling Algorithmus
Wert
π1 = max (πj − c1j ) − ε = max (0 − c1j ) − 1, 5 = −c13 − 1, 5 = −3, 5
e1j ∈E(x)
e1j ∈E(x)
Betrachten wir nun die reduzierten Kosten im Residualnetzwerk, so erhalten wir mindesten
eine zulässige Kante.
πi
0
−3, 5
i
2
−0, 5
1
3
2
−1, 5
0
cπij
4
3
3
j
0
πj
Abbildung 4.3: Reduzierte Kosten nach relabel(1)
Da mit dem neuen Potential zulässige Kanten existieren, können wir im aktiven Knoten
nun einen Push ausführen. Aus Satz 17 wissen wir, dass der Pseudofluss auch mit dem
neuen Potential ε-optimal ist. Für den Push wählen wir zunächst die Kante e13 aus. Da die
Kante über eine Kapazität von 4 verfügt und das Angebot im aktiven Knoten 6 ist, wird die
Kante gesättigt. Weiterhin wird auch der Knoten 3 zu einem aktiven Knoten, da sich nun 2
Einheiten im Knoten 2 befinden. Führen wir einen weiteren Push im aktiven Knoten 1 aus,
so wird der Kante e12 ein Fluss mit 2 Einheiten zugeordnet und das Angebot im Knoten
1 wird geleert. In diesem Fall wird auch der Knoten 2 aktiv, weil vorher keine Nachfrage
existiert hat und durch den Fluss ein positives Angebot gebildet wird. In den nachfolgenden
Abbildung 4.5 und 4.4 sehen wir das Ergebnis nach den beiden Push-Operationen.
(2; −3, 5)
(0; 0)
(bi (x); πi )
2
i
(4; −0, 5)
(2; 3)
(3; 2)
1
(4; 1, 5)
(−4; 0)
4
(uij (x); cπij )
(4; 3)
3
j
(2; 0)
(bj (x); πj )
Abbildung 4.4: push(1) mit der zulässigen Kante e13
Nach den beiden Push-Operationen ist der Knoten 1 nicht mehr aktiv. Im Residualnetzwerk existieren aber noch die aktiven Knoten 2 und 3. Wir können bereits sehen, dass keine
zulässigen Kanten für die Knoten 2 oder 3 existieren. Als nächstes müsste also ein Relabel für die Knoten 2 oder 3 ausgeführt werden. Werden genügend Discharge-Iterationen
64
4.2 Der Algorithmus
(2; 0, 5)
(2, 0)
(bi (x); πi )
2
i
(2; −0, 5)
(−4, 0)
(2; 3)
(3; 2)
1
(0, −3, 5)
(4; 1, 5)
(uij (x); cπij )
4
(4; 3)
3
j
(2, 0)
(bj (x); πj )
Abbildung 4.5: push(1) mit der zulässigen Kante e12
ausgeführt, so erhalten wir einen 1, 5-optimalen b-Fluss mit einem neuen Potential wie in
der Abbildung 4.6.
−4, 5
−3, 5
πi
i
2
2
1
2
0
4
0
4
xij
2
3
j
−4, 5
πj
Abbildung 4.6: 1, 5-optimaler b-Fluss
Die Bestimmung eines b-Flusses durch Ausführung mehrerer Discharge-Iterationen des
Cost Scaling Algorithmus ist eng mit dem Push-Relabel-Algorithmus zur Lösung eines
Maximum-Flow-Problems verwandt. Während in einer Iteration im Cost Scaling Algorithmus das Netzwerk nicht modifiziert wird, werden im Push-Relabel-Algorithmus künstliche
Start- und Zielknoten hinzugefügt. Der Startknoten wird durch künstliche Kanten mit allen Quellen verbunden und die Kapazitäten auf die Höhe des Angebots gesetzt. Senken
werden dagegen auf die gleiche Art und Weise mit dem Zielknoten verbunden. Der Startknoten bekommt weiterhin als Angebot die Summe des gesamten Angebots gesetzt und
der Zielknoten entsprechend die Summe der Nachfrage. Der Push-Relabel-Algorithmus
versucht dann dieses Maximum-Flow-Problem zu lösen [KV08, Seite 197].
Um zu zeigen, dass eine Refine-Iteration terminiert, können wir die Anzahl der möglichen
Push- und Relabel-Operationen nach oben abschätzen. Dazu zeigen wir zunächst, dass der
Pseudofluss wieder in einen b-Fluss umgewandelt werden kann.
Lemma 11 (Pfade im Residualnetzwerk). Existiert im Netzwerk N ein b-Fluss und ist
x ein Pseudofluss im selben Netzwerk, so existiert in N (x) ein Pfad P von jedem aktiven
Knoten zu einem Knoten mit negativer Balance [Zlo10, Seite 79].
65
4 Der Cost Scaling Algorithmus
0
Beweis. Sei x ein b-Fluss im Netzwerk N . Nun ist es im Netzwerk möglich, den Pseu0
dofluss x zurückzuführen und danach den Fluss x auszuführen. Betrachten wir die Resi0
dualnetzwerke N (x ) und N (x) der beiden Flüsse, so lässt sich die Differenz der beiden
Flüsse in einem neuen Fluss
0
xd = x − x
festhalten. Dabei ist zu beachten, dass für xd ein negativer Fluss auf einer Kante in eij
durch einen positiven Fluss auf der zugehörigen Rückwärtskante abgebildet wird. Dadurch
erfüllt xd die Kapaziätseinhaltung und ist ebenfalls ein Pseudofluss. Führen wir im Resi0
dualnetzwerk N (x) den Fluss xd aus, so erhalten wir demnach wider den b-Fluss x . Daher
können wir xd als eine Kombination von elementaren Flüssen auf Pfaden und Kreisen darstellen, bei der der Fluss auf jeder Kante im Pfad oder Kreis positiv ist. Dann verbindet
jeder Pfad eine Quelle mit einer Senke, um einen b-Fluss zu bilden. Insbesondere sind die
Pfade und Kreise im Residualnetzwerk N (x) enthalten. Demnach kann man die Flüsse
0
auf den Pfaden und Kreisen im Residualnetzwerk von N (x ) auch wieder zurückführen.
Das bedeutet, dass die Rückwärtskanten der Kanten in den Pfaden und Kreisen im Resi0
dualnetzwerk von N (x ) existieren.
Ist P ein Pfad von einer Quelle zu einer Senke in N (x), so existiert der Pfad Pr in
0
entgegengesetzter Richtung von P in N (x ). Pr besitzt dabei die gleiche Anzahl der Kanten
wie in P und für jede Kante in P ist die Rückwärtskante in Pr enthalten.
Lemma 12 (Anzahl der Relabel-Operation). Für einen aktiven Knoten werden in einer
Refine-Iteration maximal (1 + α) · n Relabel-Operationen ausgeführt. Weiterhin existieren
in einer Refine-Iteration maximal n − 1 aktive Knoten [Zlo10, Seite 80].
0
0
Beweis. Sei am Anfang der Iteration x der b-Fluss im Netzwerk N und π das Potential.
0
0
Nach Voraussetzung ist x am Anfang bezüglich des Potentials π ein (α · ε)-optimaler
b-Fluss. Danach wird in der Refine-Iteration ein ε-optimaler Pseudofluss gebildet. Sei nun
x ein Pseudofluss in einer Discharge-Iteration und π das dazugehörige Potential. Der Pseudofluss x und das Potential π werden in Discharge-Iterationen durch die Ausführung von
Push- und Relabel-Operationen aktualisiert. Betrachten wir eine Relabel-Operation für
einen aktiven Knoten s im Residualnetzwerk N (x), so existiert nach Lemma 11 ein s-tPfad P von s zu einem beliebigen Knoten t mit negativer Balance. Für den Pfad P sei Pr
0
der Pfad in entgegengesetzter Richtung im Netzwerk N (x ). Aus Lemma 8 ist bekannt,
dass die reduzierten Kosten einer Kante im Residualnetzwerk für einen ε-optimalen Fluss
mindestens −ε sind. Damit lassen sich die reduzierten Kosten des Pfades folgendermaßen
abschätzen:
cπ (P ) =
X
cij + πs − πt ≥ −|P | · ε
eij ∈P
0
cπ (Pr ) =
X
eji ∈Pr
66
0
0
cji + πt − πs ≥ −|Pr | · α · ε
4.2 Der Algorithmus
Da wir den entgegengesetzten Pfad betrachten, sind die Kosten der Pfade bis auf das
Vorzeichen identisch. Daraus folgt:
−
X
eij ∈P
X
cij =
cji
eji ∈Pr
0
cπ (Pr ) = −
0
X
0
cij + πt − πs ≥ −|P | · α · ε
eij ∈P
Da die Pfade P und Pr die gleiche Anzahl an Kanten besitzen gilt dann insgesamt:
0
⇔
cπ (P ) + cπ (Pr ) ≥ −|P | · ε − |P | · α · ε
X
X
0
0
cij + πs − πt −
cij + πt − πs ≥ −|P | · ε − |P | · α · ε
eij ∈P
eij ∈P
0
⇔
0
πt − πs + πs − πt ≥ −(1 + α) · |P | · ε
Aus der Tatsache, dass sich nur das Potential von aktiven Knoten ändert und Pfade nicht
mehr als n Kanten besitzen, erhalten wir
0
πs − πs ≤ (1 + α) · n · ε.
Nun können wir den Unterschied der Potentiale für einen aktiven Knoten nach einem
Relabel direkt ablesen. Da ein Relabel am Knoten s das Potential πs nach Lemma 10
0
um mindestens ε reduziert, ist πs kleiner als das Ausgangspotential πs . Aus der letzten
Ungleichung folgt damit, dass das Potential von s in einer Refine-Iteration höchstens
(1 + α) · n-mal reduziert werden kann.
Das Residualnetzwerk kann maximal über n − 1 aktive Knoten verfügen, da mindestens
ein Knoten mit negativer Balance existieren muss, wenn es sich noch nicht um einen bFluss handelt. Daher werden in einer Refine-Iteration für höchstens n − 1 Knoten maximal
(1 + α) · n Relabel-Operationen ausgeführt.
Lemma 13 (Anzahl der gesättigten Push-Operationen). In einer Refine-Iteration werden
maximal O(n · m) gesättigte Push-Operationen ausgeführt [AMO93, Seite 368].
Beweis. Nach Bildung eines Pseudoflusses in der Refine-Iteration besitzen alle Kanten
im Residualnetzwerk positive reduzierte Kosten. Daher beginnt der Algorithmus mit einer Relabel-Operation für einen aktiven Knoten i. Danach wird mindestens eine Kante
zulässig. Sei eij die zulässige Kante, für die in einer Push-Operation der Fluss auf der Kante gesättigt wird. Analysieren wir nun den Fall, dass die Kante erneut gesättigt werden
kann, so muss vorher der Fluss zurückgeführt werden. Damit das passieren kann, muss ein
Relabel im Knoten j ausgeführt werden, da die Rückwärtskante eji nach dem ersten Push
über keine negativen reduzierten Kosten verfügen kann und folglich auch nicht zulässig
ist. Wird nun der Fluss zurückgeführt, so muss die Rückwärtskante zulässig werden und
die Kante eij verfügt diesmal über keine negativen reduzierten Kosten. Für eine erneute
67
4 Der Cost Scaling Algorithmus
Sättigung muss also ein zweites Mal ein Relabel im Knoten i ausgeführt werden. Daraus
folgt, dass für jede Sättigung einer Kante auch eine Relabel-Operation notwendig ist. Da
für einen Knoten nach Lemma 12 maximal (1 + α) · n Relabel-Operationen ausgeführt werden können, kann jede Kante auch genauso oft gesättigt werden. Mit dieser Beobachtung
können insgesamt nur
(1 + α) · n · m ∈ O(n · m)
gesättigte Push-Operationen ausgeführt werden.
Bevor wir uns der Anzahl der nicht gesättigten Push-Operationen widmen, betrachten
wir zunächst die zulässigen Kanten im Netzwerk. Eine Push-Operation kann für einen
aktiven Knoten schließlich nur ausgeführt werden, wenn eine inzidente zulässige Kante
existiert.
Definition 47 (Zulässiges Netzwerk). Betrachten wir in einem Netzwerk N für einen
Pseudofluss x und Potential π das Residualnetzwerk N (x), so bilden alle Kanten mit
negativen reduzierten Kosten mit V ein zulässiges Netzwerk [AMO93, Seite 368].
In einem zulässigen Netzwerk befinden sich demnach auch alle möglichen Kandidaten
für eine zulässige Kante in einer Push-Operation. Das zulässige Netzwerk erfüllt in einer
Refine-Iteration durchgehend folgende Eigenschaft.
Lemma 14 (Zulässiges Netzwerk ist kreisfrei). Das zulässige Netzwerk ist in einer RefineIteration durchgehend kreisfrei [AMO93, Seite 368].
Beweis. Am Anfang der Refine-Iteration wird ein Pseudofluss gebildet, der alle Kanten
mit negativen reduzierten Kosten sättigt. Daher ist die Kantenmenge des zulässigen Netzwerks am Anfang leer und kreisfrei. Eine Push-Operation kann die Kantenmenge des
zulässigen Netzwerks nicht erhöhen. Da die Rückwärtskante einer zulässigen Kante nicht
negativ sein kann, kann sie nicht in das zulässige Netzwerk aufgenommen werden. Wird
die zulässige Kante in einer Push-Operation gesättigt, so verlässt sie das Residualnetzwerk und damit auch das zulässige Netzwerk. Daher kann in einem kreisfreien zulässigen
Netzwerk nach einer Push-Operation kein Kreis gebildet werden. Eine Relabel-Operation
an einem aktiven Knoten i reduziert das Potential πi und damit auch die reduzierten Kosten aller ausgehenden Kanten. Dadurch können Kanten mit negativen reduzierten Kosten
entstehen, die vorher nicht negativ waren. Insbesondere werden aber die reduzierten Kosten aller eingehenden Kanten nach Satz 17 größer oder gleich 0 und damit nicht mehr
zulässig. Daraus folgt, dass der Knoten i nur über ausgehende zulässige Kanten verfügt
und daher im zulässigen Netzwerk nicht in einem Kreis enthalten sein kann. Somit ist ein
kreisfreies zulässiges Netzwerk auch nach einer Relabel-Operation weiterhin kreisfrei. Da
am Anfang das zulässige Netzwerk kreisfrei war, ist es in der Refine-Iteration durchgehend
kreisfrei.
68
4.2 Der Algorithmus
Lemma 15 (Anzahl der nicht gesättigten Push-Operation). In einer Refine-Iteration
werden maximal O(n2 · m) nicht gesättigte Push-Operationen ausgeführt [AMO93, Seite
369].
Beweis. Da eine Push-Operation nur an aktiven Knoten ausgeführt wird, betrachten wir
die Menge der aktiven Knoten. Sei dazu S die Knotenmenge mit den aktiven Knoten.
Nun definieren wir ein Potential π, dass für jeden aktiven Knoten i die Anzahl der Knoten
festlegt, die im zulässigen Netzwerk von i aus in einem gerichteten Pfad erreichbar sind
und für alle anderen Knoten gleich 0 ist. Es gilt

Anzahl der erreichbaren Knoten,
πi =
0,
wenn i ∈ S
sonst.
Weiterhin sei
Φ=
X
πi
i∈S
die Summe der Potentiale der aktiven Knoten. Am Anfang ist Φ gleich 0, da im zulässigen
Netzwerk keine Kante existiert. Wird für einen aktiven Knoten i auf einer Kante eij eine
gesättigte Push-Operation ausgeführt, so kann der Knoten j aktiv werden, da die Balance
von j erhöht wird. Dadurch kann sich das Potential πj von 0 auf maximal n − 1 erhöhen.
Betrachten wir die maximale Anzahl der gesättigten Push-Operationen nach Lemma 13, so
wird Φ diesbezüglich maximal in der Größenordnung von O(n2 · m) erhöht. Eine RelabelOperation für einen Knoten i kann dazu führen, dass weitere Kanten in das zulässige
Netzwerk aufgenommen werden. Diese Kanten haben als Startknoten immer den Knoten
i. Dadurch kann sich das Potential in i um maximal n − 1 erhöhen. Insgesamt kann Φ nach
Lemma 12 durch Relabel-Operationen in der Größenordnung O(n3 ) wachsen.
Nun betrachten wir nicht gesättigte Push-Operationen unter Beobachtung von Φ. Wird
in einer Push-Operation für einen Knoten i eine Kante eij nicht gesättigt, so wird die
Balance im Knoten i gleich 0 und der Knoten i ist nicht mehr aktiv. Der Knoten j kann
dabei zu einen aktiv Knoten werden. Dadurch wird Φ um pii reduziert und eventuell um
πj erhöht. Weiterhin muss
πi ≥ πj + 1
gelten, da jeder Knoten, der vom Knoten j aus erreichbar ist, auch vom Knoten i aus
erreichbar gewesen sein muss. Ein nicht gesättigter Push wird den Wert von Φ also um
mindestens 1 reduzieren. Da eine Erhöhung von Φ durch Relabel- und gesättigte PushOperationen nach oben beschränkt ist, können auch nur beschränkt viele Reduzierungen durch nicht gesättigte Push-Operationen erfolgen. Die obere Schranke für Φ hat die
Größenordnung
O(n) + O(n2 · m) + O(n3 ) = O(n2 · m).
Da sich durch einen nicht gesättigten Push der Wert von Φ um mindestens 1 reduziert,
69
4 Der Cost Scaling Algorithmus
können auch nur in der gleichen Größenordnung nicht gesättigte Push-Operationen ausgeführt werden.
Satz 18 (b-Fluss in einer Refine-Iteration). Nach Ausführung einer Refine-Iteration wird
ein ε-optimaler b-Fluss gebildet. [AMO93, Seite 366]
Beweis. In einer Refine-Iteration wird nach Lemma 9 ein 0-optimaler Pseudofluss gebildet. Danach werden für aktive Knoten Push- und Relabel-Operationen ausgeführt.
Aus Satz 16 und Satz 17 wissen wir bereits, dass Push- und Relabel-Operationen nicht
die ε-Optimalität verletzen. Solange aktive Knoten existieren, können weitere Pushund Relabel-Operationen ausgeführt werden. Da die Anzahl der Push- und RelabelOperationen beschränkt ist, können nach beschränkt vielen Discharge-Iterationen keine
aktiven Knoten mehr existieren. Wenn keine aktiven Knoten mehr existieren, ist der Pseudofluss bereits ein ε-optimaler b-Fluss.
4.3 Verbesserungen
Goldberg hat in seiner Implementation des Cost Scaling Algorithmus einige heuristische
Verbesserungen aufgeführt, welches die Laufzeit des Algorithmus für viele Instanzen erheblich beschleunigen [Gol97, Seite 6]. Wir werden uns einige dieser Verbesserungen genauer
anschauen.
4.3.1 Globale Aktualisierung des Potentials
Im Cost Scaling Algorithmus wird das Potential eines Knotens innerhalb einer DischargeIteration mit einer Relabel-Operation aktualisiert. Mit einer geeigneten Heuristik können
mehrere Knotenpotentiale auf einmal aktualisiert werden. Dadurch sinkt auch die Anzahl
der Relabel-Operationen im Algorithmus. Für diese Art der globalen Aktualisierung wird
die folgende Operation benötigt.
Definition 48 (Set-Relabel). Sei S in einer Refine-Iteration eine Knotenmenge, die unter
anderem alle Knoten mit negativer Balance enthält und S̄ das Komplement der Menge S
bezüglich aller Knoten in V mit mindestens einem Knoten mit positiver Balance. Wenn
keine zulässige Kante aus einem Knoten in S̄ zu einem Knoten in S führt, reduziert eine
Set-Relabel-Operation das Potential aller Knoten in S̄ um den Wert ε [Gol97, Seite 7].
Lemma 16 (Eigenschaften von Set-Relabel). Eine Set-Relabel-Operation erfüllt folgende
Eigenschaften:
1. Der Pseudofluss bleibt ε-optimal.
2. Das zulässige Netzwerk bleibt kreisfrei.
3. Mindestens ein Knotenpotential wird reduziert.
70
4.3 Verbesserungen
4. Das Potential der Knoten mit negativer Balance bleibt unverändert.
[Gol97, Seite 7]
Beweis. Wir zeigen, dass die erste Eigenschaft gilt und der Pseudofluss ε-optimal bleibt.
Die Operation reduziert das Potential aller Knoten in der Menge S̄. Die reduzierten Kosten
der Kanten innerhalb des induzierten Subgraphs mit der Knotenmenge S̄ bleiben gleich, da
die Reduzierung um ε für jede Kante addiert und subtrahiert wird. Wir betrachten daher
nur Kanten, die von S̄ nach S führen oder umgekehrt. Nach Voraussetzung existiert keine
zulässige Kante, die von S̄ nach S führt. Sei x der aktuelle Fluss. Daraus folgt, dass jede
Kante mit Restkapazität, die von S̄ nach S führt über positive reduzierte Kosten verfügt.
Betrachten wir die Kanten, die von S nach S̄ führen, so existieren zwei Fälle. Die Kanten
haben einen leeren Fluss mit reduzierten Kosten größer als 0 oder einen positiven Fluss
mit reduzierten Kosten kleiner oder gleich 0, da ansonsten zulässige Rückwärtskanten von
S̄ nach S führen würden. Vor der Operation gilt daher insgesamt folgendes:
eij ∈ E(x) : i ∈ S̄ und j ∈ S =⇒ cπij ≥ 0 und xij < uij
eij ∈ E(x) : i ∈ S und j ∈ S̄ =⇒ cπij > 0 und xij = 0 oder
− ε ≤ cπij ≤ 0 und uij > xij ≥ 0
Nach einer Set-Relabel-Operation ändern sich die reduzierten Kosten der aufgeführten
Kanten. Während die reduzierten Kosten der Kanten, die von S̄ nach S führen, um ε
reduziert werden, erhöhen sich die reduzierten Kosten der Kanten, die von nach S nach S̄
führen um denselben Wert. Für die neuen reduzierten Kosten gilt dann insgesamt folgendes:
eij ∈ E(x) : i ∈ S̄ und j ∈ S =⇒ cπij ≥ −ε und xij < uij
eij ∈ E(x) : i ∈ S und j ∈ S̄ =⇒ cπij > ε und xij = 0 oder
0 ≤ cπij ≤ ε und uij > xij ≥ 0
Die neuen reduzierten Kosten erfüllen die Bedingungen der ε-Optimalität. Als nächstes
betrachten wir die zweite Eigenschaft und zeigen, dass das zulässige Netzwerk kreisfrei
ist. Da das zulässige Netzwerk nur aus Kanten mit negativen reduzierten Kosten besteht,
müsste ein Kreis im neuen zulässigen Netzwerk negative Kosten haben. Weiterhin kann
ein Kreis nur aus Knoten in der Menge S oder S̄ existieren, da nach der Operation keine
zulässige Kante von S nach S̄ führt, wie man an der Umformung oben sehen kann. Sei C
der Kreis im neuen zulässigen Netzwerk bezüglich des neuen Potentials. Da für Kreise die
Kosten mit den reduzierten Kosten nach der Gleichung 2.4 übereinstimmen, folgt:
cπ (C) =
X
eij ∈C
cπij =
X
cij ≤ −|C|
eij ∈C
Der Kreis hätte demnach auch im ursprünglichen zulässigen Netzwerk sein müssen, weil
71
4 Der Cost Scaling Algorithmus
die reduzierten Kosten der Kanten in S oder S̄ gleich geblieben sind. Das stellt aber
einen Widerspruch zur Annahme dar. Das zulässige Netzwerk ist demnach kreisfrei. Die
Eigenschaften 3 und 4 folgen direkt aus der Definition der Set-Relabel-Operation.
Durch diese Heuristik enthält im Algorithmus am Anfang einer Refine-Iteration die Menge S alle Knoten mit negativer Balance. In allen folgenden Discharge-Iterationen werden
der Menge S alle Knoten hinzugefügt, die durch eine zulässige Kante mit einem Knoten in
der Menge S inzident sind. Enthält nach einer Relabel-Operation schließlich S alle Knoten
mit positiver Balance, wird die Set-Relabel-Operation nicht ausgeführt. Ansonsten wird
Set-Relabel für alle Knoten in S̄ ausgeführt [Gol97, Seite 7].
Durch die globale Aktualisierung des Potentials wird die Laufzeit des Algorithmus für
Instanzen einiger Problemklassen asymptotisch verbessert, während sie in den anderen
Problemklassen keinen relevanten Nachteil darstellt [Gol97, Seite 6]. Die Operation kann
sowohl wie beschrieben nach jedem Relabel ausgeführt werden, als auch gelegentlich nach
einer bestimmten Anzahl von Relabel-Operationen [Gol97, Seite 8].
4.3.2 Verfeinerung des Potentials
In jeder Refine-Iteration wird der Wert von ε durch den Skalierungsfaktor α geteilt und
verkleinert. Der neu gebildete b-Fluss ist dann
ε
α -optimal.
Nun kommt es oft vor, dass der
neue b-Fluss selbst für kleinere ε Werte ε-optimal ist. Unter Umständen muss dafür nur
das Potential angepasst werden [Gol97, Seite 8].
Algorithmus 5 : Verfeinerung des Potentials [Gol97, Seite 9]
di := 0 ∀ i ∈ V
cπ
while Es existiert dj > di + d εij e do
cπ
dj := di + d εij e
B−dj := B−dj ∪ {j}
for all Bd 6= ∅ beginne mit dem größten Index dmax do
while Bdmax 6= ∅ do
Bdmax := Bdmax \ {i}
if cπij < 0 und dj > di then
B−dj := B−dj \ {j}
dj := di
B−dj := B−dj ∪ {j}
if cπij ≥ 0 und dj > di + d
B−dj := B−dj \ {j}
cπ
dj := di + d εij e
B−dj := B−dj ∪ {j}
for all i ∈ V do
πi := πi + di
72
cπ
ij
ε e
then
4.3 Verbesserungen
Ist der Fluss α · ε-optimal, so versucht die Heuristik ein Potential zu finden, für den der
Fluss auch ε-optimal ist. Dazu muss der zulässige Graph kreisfrei sein, da sonst kein Potential gefunden werden kann [Gol97, Seite 8]. Man konnte nur mit kreisfreien zulässigen
Graphen die Anzahl der Iteration begrenzen und somit die Terminierung sicherstellen. Ist
der zulässige Graph kreisfrei, berechnet die Heuristik aus allen Knoten mit einem Eingangsgrad von 0 eine Entfernung d bezüglich des Potentials zu allen anderen Knoten. Die
Einheit der Entfernung entspricht dem Wert von ε und ist nicht positiv, da initial die
Entfernungen für alle Knoten mit 0 belegt werden und nur noch kleineren Entfernungen
gesucht wird. Um Knoten mit der gleichen Entfernung zusammenzufassen, werden im Algorithmus Knotenmengen verwendet. Die Mengen werden mit B bezeichnet und enthalten
als Index die negative Entfernung. Da alle berechneten Entfernungen nicht positiv sind,
werden die Indizes 0 oder positiv sein.
Wenn der Algorithmus 5 durchgeführt und der Fluss mit dem neuen Potential nicht
ε-optimal ist, wird der Algorithmus erneut durchgeführt. Wenn durch die Änderung des
Potentials ein Kreis im zulässigen Graph entsteht, bricht die Heuristik ab und der Cost
Scaling Algorithmus arbeitet weiter. Wird kein Kreis gefunden, so erfüllt das Potential die
Bedingung der ε-Optimalität [Gol97, Seite 9].
4.3.3 Kanten auslassen
Der Cost Scaling Algorithmus betrachtet jede Kante, um einen ε-optimalen Fluss zu bilden.
Während für Kanten mit reduzierten Kosten größer als ε oder kleiner als −ε der Fluss
vorgegeben ist, kann der Fluss nur für Kanten mit reduzierten Kosten innerhalb von
−ε und ε variable gehalten werden. Ausgehend von dieser Beobachtung, werden durch
diese Heuristik Kanten mit zu großen oder kleinen reduzierten Kosten bis zum Ende des
Algorithmus in Discharge-Iteration nicht weiter betrachtet. Als Richtwert werden Kanten
mit betragsmäßigen reduzierten Kosten größer als 2nε im Algorithmus ignoriert. Es können
auch andere Richtwerte benutzt werden [Gol97, Seite 9].
4.3.4 Push Operationen eliminieren
Während der Ausführung des Cost Scaling Algorithmus kann der Fall eintreten, dass einer
Kante zwischen zwei aktiven Knoten i und j aus V ein positiver Fluss xij zugeordnet wird.
Anschließend kommt es unter Umständen vor, dass in späteren Iterationen der Fluss auf
der Kante verringert oder sogar annulliert wird. Dieser Fall kann nur eintreten, wenn der
Knoten j über keine zulässigen Kanten verfügt hatte, als am Anfang xij ein positiver Wert
zugewiesen wurde. Solche Situationen erhöhen die Laufzeit des Algorithmus unnötig. Die
Heuristik zur Eliminierung von Push-Operationen setzt auf dieser Beobachtung auf und
versucht solche Situationen im Voraus zu beheben.
Die Heuristik kontrolliert vor Ausführung einer Push-Operation die Balance und zulässigen Kanten des Zielknotens. Handelt es sich nicht um einen Knoten mit negativer Balance
oder existieren zulässige Kanten, wird der Fluss durchgeführt. Andernfalls wird auf den
73
4 Der Cost Scaling Algorithmus
Zielknoten eine Relabel-Operation angewandt und dadurch der Fluss auf der Kante eij annulliert. Ist der Knoten j nicht aktiv, kann die Relabel-Operation nach Definition 45 nicht
angewandt werden. Dann wird kontrolliert, ob aus j ein Knoten mit negativer Balance
erreichbar ist oder nicht. Im ersten Fall kann die Relabel-Operation trotzdem erfolgreich
angewandt werden. Im letzten Fall kann die Relabel-Operation auch angewandt werden,
wenn j keine ausgehenden Kanten im Residualgraphen besitzt. Hat j gar keine ausgehenden Kanten, kann das Potential von j sogar um einen beliebigen Wert ohne Verletzung
der ε-Optimalität reduziert werden [Gol97, Seite 10].
4.4 Laufzeit
Satz 19 (Laufzeit des Cost Scaling Algorithmus). Die Laufzeit des Cost Scaling Algorithmus ist in der Größenordnung von O(n2 · m · logα (n · cmax )) [AMO93, Seite 370] [Zlo10,
Seite 85].
Beweis. In einer Refine-Iteration werden in der Größenordnung von O(n2 · m) nicht
gesättigte Push-Operationen und O(n · m) gesättigte Push-Operationen durchgeführt. Um
eine zulässige Kante zu finden, muss nach Erhöhung eines Potentials für alle Knoten die
Kantenmenge auf Zulässigkeit überprüft werden. Dabei kommen maximal
n·
X
|δ(i)| ≤ n · m
i∈V
Kanten in Betracht und es sind maximal O(n · m) Schritte nötig. Werden alle aktiven
Knoten in einer Liste gespeichert, so benötigt man zum Finden eines aktiven Knotens
nur einen Schritt. Insgesamt braucht eine Refine-Iteration dann O(n2 · m) Schritte. Bis
der resultierende b-Fluss optimal ist, muss der Wert für ε nach Satz 15 kleiner als
1
n
sein.
Dafür müssen
1 + logα (n · cmax )
Refine-Iterationen ausgeführt werden, was einer Größenordnung von O(logα (n · cmax ))
entspricht. Insgesamt braucht der Algorithmus dann O(n2 · m · logα (n · cmax )) Schritte.
74
5 Vergleich verschiedener Algorithmen
In diesem Kapitel werden einige Algorithmen miteinander verglichen. Dabei gibt es verschiedene Programme, in denen die eingeführten Algorithmen umgesetzt sind. Viele Programme nutzen weitere Verfahren und Datenstrukturen, um schneller eine Lösung zu finden. Danach stellen wir die Problemklassen vor, die wir mit den Programmen zu lösen
versuchen werden. Schließlich präsentieren wir die Ergebnisse und versuchen diese zu analysieren.
5.1 Algorithmen und Programme
Um Minimum Cost Flow Probleme zu lösen, werden wir verschiedene Programme nutzen.
Das das Minimum Cost Flow Problem als ein lineares Programm formuliert wird, setzen
wir einige Programme ein, die lineare Programme lösen können. Diese Programme nutzen in der Regel eine Implementation des Simplex Algorithmus. Unter Berücksichtigung
der Problemstruktur werden die Programme jedoch den schnelleren Netzwerk Simplex Algorithmus einsetzen. Eines dieser Programme ist der IBM ILOG CPLEX1 in der Version
12.1.0, den wir kurz als CPLEX bezeichnen werden. Die Bezeichnung CPLEX geht zurück
auf die Implementation des Simplex Algorithmus in der Programmiersprache C. Weiterhin
setzen wir den LP Löser Gurobi Optimizer2 in der Version 4.5 ein. Diesen werden wir mit
GUROBI bezeichnen. Für den Netzwerk Simplex Algorithmus nutzen wir schließlich noch
die Implementation von Andreas Löbel in der Version 1.3, welche unter dem Namen MCF
- A Network simplex implementation 3 bekannt ist und verwenden dafür die Abkürzung
MCF.
Für den Cost Scaling Algorithmus verwenden wir das Programm IG Systems CS2 4
in der Version 4.6. Das Programm baut auf der Implementation von Goldberg aus dem
Jahr 1997 auf und wurde von dem Unternehmen IG Systems weiterentwickelt. Für dieses
Programm verwenden wir die Bezeichnung CS.
Alle Programme sind auf einem 64-Bit Linux Betriebssystem installiert und werden auf
R CoreTM i7-870 Prozessor5 und vier GB Arbeitsspeieinem Computer mit einem Intel
cher ausgeführt. Für alle Programme werden Versionen mit freien akademischen Lizenzen
1
IBM ILOG CPLEX V12.1 Online Manual:
ftp://ftp.software.ibm.com/software/websphere/ilog/docs/optimization/cplex/ps usrmancplex.pdf
2
Gurobi Optimizer Version 4.5 Online Documentation: http://www.gurobi.com/doc/45/quickstart/
3
MCF Homepage: http://typo.zib.de/optlong projects/Software/Mcf/
4
IG Systems CS2 Homepage: http://www.igsystems.com/cs2/
5
TM
R Core
Intel
i7-870 Prozessor Spezifikationen: http://ark.intel.com/Product.aspx?id=41315
75
5 Vergleich verschiedener Algorithmen
genutzt. Für den CPLEX Optimizer nutzen wir die Version 12.1.0 mit einer IBM ILOG
Optimization Suite for Academic Initiative Lizenz, ausgestellt für die Technische Universität Berlin.
Die Programme geben für ein Problem neben der Lösung auch die Zeit in Sekunden
aus. Die Zeit wird in allen Programmen auf eine Hundertstelsekunde genau ausgegeben.
Das Programm MCF von Andreas Löbel gibt für Probleme mit längeren Laufzeiten die
Zeit nur noch auf Sekunden genau aus.
Programm (Version)
GUROBI (4.5)
CPLEX (12.1.0)
MCF (1.3)
CS (4.6)
Algorithmus
NSA
NSA
NSA
CSA
Veröffentlichung
April 2011
Juli 2009
6. Mai 2004
24. November 2009
Tabelle 5.1: Programme zum Lösen von Minimum Cost Flow Problemen
5.2 Problemklassen
Zum Vergleichen der Programme benutzen wir Minimum Cost Flow Probleme in verschiedenen Größen. Dabei ist die Anzahl der Knoten und Kanten maßgebend, da sie auch die
Laufzeit der Algorithmen direkt beeinflussen. Die Instanzen erstellen wir mit einigen Generatoren, die auf der Homepage der DIMACS6 frei zur Verfügung stehen. Sie wurden
unter anderem von A. Goldberg, Y. Lee, J. Orlin, M. Resende, D. Klingman, A. Napier
und J. Stutz entwickelt.
Wir schauen uns nun die Generatoren genauer an. Die Instanzen, die von einem Generator erstellt werden besitzen spezielle Eigenschaften und werden im MIN-Dateiformat
ausgegeben. Weiterhin erwarten die Generatoren zum Erstellen einer Instanz mehrere Eingabeparameter wie zum Beispiel die Anzahl der Knoten und Kanten.
5.2.1 Grid-On-Torus
Der Grid-On-Torus (GOTO) Generator wurde von Goldberg entwickelt [GK93, Seite 195].
Zur Erstellung eines Minimum Cost Flow Problems erwartet der Generator folgende fünf
Parameter:
Die Instanzen verfügen über genau eine Quelle und eine Senke. Den erzeugten Graphen kann man sich als ein kariertes Rechteck vorstellen, wobei die Knoten genau an
den Schnittpunkten liegen. In jeder Ebene und Spalte existiert eine bestimmte Anzahl
an Knoten. Existieren mehr Knoten als das Rechteck aufnehmen kann, so wird eine neue
unvollständige Zeile gebildet. Die Knoten liegen in einer Zeile nebeneinander und in einer
Spalte untereinander. Die Quelle liegt ganz oben links und die Senke in der untersten
vollständigen Ebene rechts. Jeder Knoten, bis auf den letzten in einer Ebene, verfügt
6
DIMACS Netzwerk Generatoren: ftp://dimacs.rutgers.edu/pub/netflow/generators/network/
76
5.2 Problemklassen
Parameter
n = |V |
m = |E|
umax
cmax
seed
Beschreibung
Anzahl der Knoten, die mindestens 15 sein muss.
5
Anzahl der Kanten, wobei 6 · n ≤ m ≤ n 3 gelten muss.
Die maximale Kapazität einer Kante, die mindestens 8 sein muss.
Die maximalen Kosten einer Kante, mindestens 8.
Zahl, um eine feste Zufallszahl zu generieren.
Tabelle 5.2: Eingabeparameter für GOTO
über eine Kante mit geringer Kapazität und geringen Kosten, die horizontal nach rechts
verläuft. Jeder Knoten ist über mehrere Kanten mit einigen Knoten in der gleichen Spalte, die einer vollständigen Ebene angehört, inzident. Dabei können auch parallele Kanten
existieren. Die Anzahl der Knoten und Kanten müssen so gewählt werden, dass für die
Dichte d die Ungleichung
5
6 · n ≤ d · n ≤ n3
erfüllt ist. Mit der Dichte lassen sich die Instanzen in weitere Problemklassen unterteilen.
So spricht Goldberg von GOTO-8, GOTO-16 und GOTO-I Problemklassen, die den Faktor
√
8, 16 und b nc als Dichte besitzen.
Bei allen mit dem GOTO Generator erstellten Instanzen benutzen wir für die maximale
Kapazität und die maximalen Kosten den Wert 216 respektive 65536. Die Kosten und
Kapazitäten der Kanten werden mit einem Zufallsgenerator zwischen dem minimalen und
maximalen Wert zufällig bestimmt. Während Kosten auch den Wert 0 haben können, liegt
der Mindestwert für eine Kapazität bei 1. Um die gleichen Instanzen erneut erstellen zu
können, benutzen wir für den Parameter seed den Wert 2011.
Wir betrachten als nächstes ein Beispiel mit 16 Knoten und 96 Kanten als Eingabeparameter. Die Dichte beträgt in unserem Beispiel 6. Um die Instanzen überschaubar
darzustellen, betrachten wir drei Graphen mit der gleichen Knotenmenge und drei unterschiedlichen Kantenmengen. Die folgende Unterteilung in drei verschiedene Kantenmengen
ist für jede Instanz aus dem GOTO Generator möglich. Das gesamte Beispiel besteht dann
aus alle Kanten in den drei Graphen.
In der ersten Kantenmenge wird eine Lösung des Problems garantiert. Die Kanten auf
dem Lösungspfad sind die teuersten Kanten in der Instanz. Diese Lösung besteht aus
einem langen Pfad, die über die Kapazität des gesamten Angebots verfügt.
Die Anzahl der Kanten ist für die erste Kantenmenge bezüglich der Anzahl der Knoten
fest. In unserem Beispiel besitzt der Lösungspfad 15 Kanten und hat Kosten in Höhe von
15 · 214 · 120693 = 29661511680.
Die Gesamtkosten betragen für diese Lösung mehr als 29 Milliarden, während die Optimallösung ungefähr 3, 16 Milliarden7 kostet.
7
Die Lösung wurde mit CPLEX berechnet.
77
5 Vergleich verschiedener Algorithmen
120693
1
2
3
4
bi
5
6
7
8
i
(uij = 120693; cij = 16384)
9
10
11
j
12
bj
13
14
15
16
−120693
Abbildung 5.1: Lösungspfad in der GOTO Instanz
Als nächstes betrachten wir die Kanten, die von jedem Knoten zu einigen Knoten in der
gleichen Spalte und zu einem rechts neben dem Knoten existierenden Knoten verlaufen.
Auch diese Kanten existieren in jeder Instanz des GOTO Generators. Je größer die Dichte
und somit die Anzahl der Kanten ist, mit umso mehr Knoten aus der gleichen Spalte
ist ein Knoten inzident. Dabei wählt der Generator beim Hinzufügen einer neuen Kante
zuerst die Knoten, die im Gitter unterhalb und näher am Knoten liegen, aus. Ist die Dichte
gering, so sind die Knoten meistens nur mit weiteren Knoten nach unten inzident und nicht
in umgekehrter Richtung.
120693
1
2
3
4
bi
5
6
7
8
i
9
10
11
12
j
bj
13
14
15
16
−120693
Abbildung 5.2: Standardkanten im GOTO Netzwerk
78
5.2 Problemklassen
Der Name des Generators beschreibt im wesentlichen diesen Graphen. Es handelt sich
hierbei nämlich um einen zweidimensionalen Torus, der in eine X- und Y -Ebene eingebettet ist [GK93, Seite 196]. Der Graph in Abbildung 5.2 besitzt 60 Kanten, wobei je 12
Kanten in einer Spalte verlaufen. Die Kapazitäten und Kosten dieser Kanten sind unterschiedlich. Kanten die in der gleichen Spalte verlaufen sind mit Kosten zwischen 0 und 7
relativ günstig im Vergleich zu den zwischen 3697 und 57687 kostenden Kanten die zum
Nachbarn in der gleichen Zeile verlaufen. Die Kapazitäten der Kanten in der gleichen Spalte reichen von 1271 bis 64592. Kanten die horizontal verlaufen besitzen Kapazitäten von
92 bis 56160. Die Kapazitäten der horizontal verlaufenden Kanten schrumpfen je weiter
sie sich rechts befinden [Gol97, Seite 12].
In den ersten beiden Graphen existiert keine Kante, die nach links verläuft oder quer
zu einem Knoten in einer anderen Ebene und Spalte, was auf die letzte Kantenmenge
im dritten Graphen nicht zutreffen muss. Im letzten Graphen befinden sich die restlichen
21 Kanten. Auch die Anzahl der Kanten in der dritten Menge wächst zusätzlich mit der
Dichte.
120693
1
2
3
4
bi
5
6
7
8
i
9
10
11
12
j
bj
13
14
15
16
−120693
Abbildung 5.3: Weitere Kanten im GOTO Netzwerk
Bei den restlichen Kanten fällt auf, dass alle mit der Quelle und Senke inzidenten Kanten
über relativ hohe Kosten zwischen 3262 und 61864 verfügen, während alle anderen Kanten
mit Kosten zwischen 0 und 7 sehr günstig sind. Die Kapazitäten reichen für eine Kante
von 431 bis 62775.
5.2.2 GRIDGRAPH
Den GRIDGRAPH Generator haben Resende und Veiga entwickelt [RV93]. Wir benutzen
die Implementation in der Programmiersprache FORTRAN, die auf der Internetseite der
79
5 Vergleich verschiedener Algorithmen
DIMACS frei zur Verfügung steht. Die Implementation erlaubt nur die Erstellung von
Netzwerken mit weniger als einer Million Kanten.
Der Generator erstellt ein rechteckiges Gitter, in dem pro Zeile und Spalte eine bestimmte Anzahl an Knoten ist. Die Quelle ist dabei mit allen Knoten am linken Rand und
die Senke mit allen Knoten am rechten Rand inzident. Zur Erstellung einer Instanz des
Minimum Cost Flow Problems müssen dem Generator folgende fünf Parameter mitgeteilt
werden:
Parameter
x
y
umax
cmax
seed
Beschreibung
Anzahl der Knoten, die in einer Zeile nebeneinander liegen.
Anzahl der Knoten, die in einer Spalte untereinander liegen.
Die maximale Kapazität einer Kante, die mindestens 8 sein muss.
Die maximalen Kosten einer Kante, mindestens 8.
Zahl, um eine feste Zufallszahl zu generieren.
Tabelle 5.3: Eingabeparameter für GRIDGRAPH
In den Instanzen beträgt die Anzahl der Knoten
n=2+x·y
und die Anzahl der Kanten ist mit
m=
(x + 1) · y
| {z }
horizontale Kanten
+ (y − 1) · x = 2 · x · y + y − x
| {z }
vertikale Kanten
für eine Instanz fest vorgegeben.
Wie beim GOTO-Generator verwenden wir für auch für den GRIDGRAPH-Generator
die Werte 65536 für umax und cmax und den Wert 2011 für seed.
Wir zeigen als nächstes ein Beispiel mit 4 Knoten pro Zeile und Spalte.
1
2
3
4
bi
4128
5
6
7
8
17
-4128
18
9
10
11
12
i
cij = 1032
j
bj
13
14
15
16
Abbildung 5.4: Kanten im GRIDGRAPH Netzwerk
80
5.2 Problemklassen
Die Kosten aller Kanten sind mit 1032 identisch. Die Kapazitäten der Kanten betragen
bis auf die dicken Kanten 1032 Einheiten. Die dicken Kanten verfügen mit 2064 Einheiten
über genau doppelt so viele Kapazitäten wie die restlichen Kanten. Die optimale Lösung
beträgt genau
5
|{z}
· 1032
|{z} · 4128
|{z} = 21300480
Anzahl der Kanten auf einem vertikalen Pfad Kosten Angebot
und somit über 21 Millionen. Das Angebot beträgt dabei das vierfache der Kapazitäten
der inneren Kanten.
In allen Instanzen wird die Kapazität der inneren Kanten mit einem Zufallszahlengenerator bestimmt. Das Angebot beträgt dann immer das Produkt der Anzahl der Knoten
pro Spalte mit der inneren Kantenkapazität. Die mit der Quelle inzidenten Kanten sind
bis auf die letzte Kante immer doppelt so groß wie die inneren Kantenkapazitäten. Für
die mit der Senke inzidenten Kanten sind die Kapazitäten aller Kanten bis auf die erste
doppelt so groß. Diese Struktur ist unabhängig von der Anzahl der Knoten in einer Spalte
immer gegeben.
Für die Instanzen aus dem GRIDGRAPH-Generator kann man folgende drei Problemklassen bilden:
GRID-SQUARE:
GRID-WIDE:
GRID-LONG:
x=y
y = 16, x > 16
y > 16, x = 16
Tabelle 5.4: Problemklassen im GRIDGRAPH-Generator[RV93]
Während GRID-SQURAE quadratische Netzwerke erstellt, sind die Netzwerke in GRIDWIDE und GRID-LONG rechteckig. Der Unterschied in den rechteckigen Netzwerken ist
die Anzahl der Kanten eines kürzesten Pfades von der Quelle zur Senke. In GRID-LONG
Netzwerken beinhaltet der kürzeste Pfad immer 15 Kanten, da x mit 16 einen festen Wert
erhält. In GRID-WIDE Netzwerken wächst hingegen der Wert von x mit der Anzahl der
Knoten im Netzwerk.
5.2.3 NETGEN
Der NETGEN Generator wurde von Klingman et al. entwickelt und kann abhängig von
den Eingabeparametern Transport-, Zuordnungs- und Minimum Cost Flow Probleme erstellen [KNS74, Seite 814]. Der Generator arbeitet in zwei Phasen, um eine Instanz zu
erstellen. In der ersten Phase werden die Knoten samt Quellen und Senken erstellt. Mit
einer minimalen Anzahl an Kanten wird ein zusammenhängender Graph gebildet und eine
Lösung garantiert. In der Lösung ist dabei jede Quelle durch einen Pfad mit einer zufälligen Anzahl von Senken durch einen Pfad verbunden. Das Netzwerk, das nach der ersten
Phase steht, wird Skelett genannt [KNS74, Seite 816]. In der zweiten Phase erstellt der
81
5 Vergleich verschiedener Algorithmen
Generator dann die restlichen Kanten mit unterschiedlichen Werten für die Kosten und
Kapazitäten. Im gesamten Netzwerk existieren insbesondere keine parallelen Kanten.
Wir benutzen eine in der Programmiersprache C geschriebene Version aus der Internetseite von DIMACS8 , welche die Probleme im MIN-Dateiformat ausgibt. Diese Version
wurde speziell angepasst, um relativ große Probleme mit vielen Knoten und Kanten zu
erstellen. Zur Erstellung einer Instanz erfordert der Generator fünfzehn Parameter. In der
Tabelle 5.5 geben wir die Parameter mit dem Wert, den wir für unsere Instanzen nutzen
werden, an.
Parameter
seed
problem
nodes
sources
sinks
density
mincost
maxcost
supply
tsources
tsinks
hicost
capacitated
mincap
maxcap
Wert
2011
2n
2n · 81 = 2n−3
2n · 81 = 2n−3
2n · 8 = 2n+3
0
216 = 65536
2n · 16 = 2n+4
0
0
100 in %
100 in %
1
216 = 65536
Beschreibung
Zahl, um eine feste Zufallszahl zu generieren.
Dient zur Dokumentation der Ausgabe.
Anzahl der Knoten.
Anzahl der Quellen.
Anzahl der Senken.
Anzahl der Kanten.
Die minimalen Kosten einer Kante.
Die maximalen Kosten einer Kante.
Das gesamte Angebot.
Anzahl der Umschlags-Quellen.
Anzahl der Umschlags-Senken.
Anteil der Kanten mit maximalen Kosten im Skelett.
Anteil der Kanten mit Kapazitäten.
Die minimale Kapazität einer Kante.
Die maximale Kapazität einer Kante.
Tabelle 5.5: Eingabeparameter für NETGEN und Werte in unseren Instanzen
Da wir ein Minimum Cost Flow Problem erstellen werden, werden wir die Parameter
für tsources und tsinks auf 0 setzen. Wie bei den anderen Generatoren werden wir für
die maximale Kapazität und die maximalen Kosten einer Kante den Wert 65536 benutzen. Da Kanten auch kostenlos sein können, wird der Wert für mincost auf 0 gesetzt,
aber der Wert für mincap auf 1, da Kanten ohne Kapazitäten für unsere Problemstellung
uninteressant sind. In dem wir capacitated gleich 100 setzen, erreichen wir, dass jede
Kante eine Kapazität besitzt. Für die Instanzen werden wir im Generator den Parameter
hicsot auf 100 setzen, damit alle Kanten in der ersten Phase sehr teuer sind und in einer
optimalen Lösung möglichst nicht vorkommen. Die Anzahl der Kanten entspricht in unseren Instanzen dem achtfachen der Anzahl der Knoten. Die Dichte der Instanzen beträgt
somit 8.
Der NETGEN Generator unterscheidet sich von den anderen zwei Generatoren darin,
dass die Knoten nicht auf einem Gitter angeordnet sind. Weiterhin können in den Instanzen
des NETGEN Generators weitaus mehr als nur eine Quelle und Senke existieren.
Wir betrachten nun ein überschaubares Beispiel mit 8 Knoten und 16 Kanten. Dieses
8
ftp://dimacs.rutgers.edu/pub/netflow/generators/network/netgen/netgen-bcjl/
82
5.2 Problemklassen
Beispiel hat im Gegensatz zu den Instanzen, die wir zur Auswertung benutzen werden,
eine Dichte von nur 2. Zuerst betrachten wir das Skelett, das in der ersten Phasen des
Generators erstellt wird und danach die restlichen Kanten. Die gesamte Instanz besteht
dann aus den Kanten in beiden Phasen. Im Skelett unserer Instanz existieren 8 Kanten.
203
1
6
5
bi
i
−64
8
2
(uij = 64;cij = 65536)
j
bj
3
4
7
Abbildung 5.5: Skelett im NETGEN Netzwerk
In der Abbildung 5.5 ist ein Pfad von der Quelle zur Senke eindeutig zu erkennen. In
allen Instanzen des NETGEN Generators existieren solche Pfade. Als nächsten betrachten
wir die restlichen 8 Kanten.
64
1
6
5
bi
i
−64
8
2
j
bj
3
4
7
Abbildung 5.6: Restliche Kanten im NETGEN Netzwerk
In unserer Instanz betragen die Kosten der restlichen Kanten zwischen 11202 und 61741.
Die Kapazitäten schwanken für eine Kante hingegen zwischen 19229 und 5302.
5.2.4 TCHAIN
Die TCHAIN Problemklasse wurde von mir für diese Diplomarbeit entwickelt. Neben den
drei klassischen Problemklassen, die inzwischen über 20 Jahre alt sind, soll diese Problemklasse weitere Ergebnisse zum Vergleichen der vier Programme liefern. Der Quellcode in
der Programmiersprache C ist im Anhang der Diplomarbeit auf Seite A zu finden.
Zum Erstellen einer Instanz benötigt man beim Aufruf des Generators zwei Parameter,
83
5 Vergleich verschiedener Algorithmen
die Anzahl der Knoten und die Dichte. Weiterhin sind zwei weitere Parameter im Quellcode
änderbar.
Parameter
seed
nodes
density
radius
Wert
2011
2n
8
8
Beschreibung
Zahl, um eine feste Zufallszahl zu generieren.
Anzahl der Knoten.
Dichte
Maximale Entfernung der Kanten als Anteil der Kanten.
Tabelle 5.6: Eingabeparameter für TCHAIN und Werte in unseren Instanzen
Den Generator haben wir TCHAIN getauft, da die Knoten in Form einer Kette nebeneinander liegen. Das T am Anfang steht für das englische Wort für Dreieck, triangle.
Die Dichte der einzelnen Kanten wird in Form eines Dreiecks bestimmt, wozu wir später
zurückkommen.
Der TCHAIN Generator erstellt eine Instanz in zwei Phasen. In der ersten Phase werden die Knoten erstellt und durch Kanten nacheinander verbunden, um eine Lösung zu
garantieren. Die ersten Kante ist dabei die Quelle mit einem Angebot, das dem doppeltem
der Anzahl der Knoten entspricht. Die letzte Kante stellt in einer Instanz die Senke dar.
Die Kosten der Kanten aus der ersten Phase betragen immer 1 und die Kapazitäten der
Kanten entsprechen dem Gesamtangebot. In der zweiten Phase werden je nach Größe der
Dichte weitere Kanten erstellt. Alle Kanten richten sich von der Quelle zur Senke hin. Dabei kann eine Kante höchstens
nodes
radius
Knoten überspringen. Die Kosten und Kapazitäten
werden durch den Zufallsgenerator bestimmt. Die Kapazität liegt dabei zwischen 1 und
der Anzahl der Knoten. Die Kosten richten sich nach der Anzahl der Knoten, die eine
Kante in der Kette überspringt. Sie können zwischen 0 und der doppelten Anzahl der
Knoten liege, die die Kante übersprungen hat. Weiterhin sind die Kosten am Anfang der
Kette günstiger als Kanten am Ende der Kette.
In der Instanz wird die Dichte des Netzwerks auf jeden einzelnen Knoten verteilt. Die
Verteilung der Kanten bildet den Fall ab, dass bei einer weiten Entfernung mehrere Wege
zum Ziel führen können, jedoch die Anzahl der Möglichkeiten sinkt, wenn wir uns näher
am Ziel befinden.
2·d
d
n·d
n·d
n
Abbildung 5.7: Dichte in der TCHAIN Problemklasse
84
n
5.3 Auswertung der Instanzen
Betrachten wir die Anzahl der Knoten n und die Dichte d in einem Netzwerk, so ergeben
sich n · d Kanten. Mann könnte sich vorstellen, dass jeder Knoten d Kanten besitzt. Ausgehend von dieser Beobachtung, verteilen wir die Anzahl der Kanten eines Knotens gemäß
eines Dreiecks wie in der Abbildung 5.7. So besitzt der erste Knoten in der Instanz 2 · d
Kanten und der letzte keine. Die Dichte des Netzwerks bleibt davon unbeeinflusst. Trotzdem führen Rundungsfehler bei der Berechnung der Anzahl der Kanten eines Knotens
dazu, dass die Anzahl der Kanten im Netzwerk nicht exakt n · d entspricht.
Als nächstes betrachten wir ein Beispiel mit fünf Kanten und der Dichte drei.
bi
i
−10
10
1
2
3
4
5
j
bj
Abbildung 5.8: Eine Instanz der TCHAIN Problemklasse
Alle Kanten, die nicht gekrümmt sind, haben Kosten in Höhe von 1 und Kapazitäten in
Höhe von 10. Die gekrümmten Kanten besitzt Kosten zwischen 0 und 8 und Kapazitäten
zwischen 1 und 5.
5.3 Auswertung der Instanzen
Mit den eingeführten Generatoren werden wir insgesamt sieben Problemklassen erstellen.
Diese sind GOTO-8, GOTO-I, GRID-SQUARE, GRID-WIDE, GRID-LONG, NETGEN
und TCHAIN. In jeder Problemklasse werden wir mehrere Instanzen in verschiedenen
Größen erstellen. Die erste Instanz wird dabei mit 1024 bzw. 1026 Knoten die Kleinste
sein.
Da der Gurobi Optimizer das von der DIMACS spezifizierte MIN-Dateiformat nicht
lesen kann, werden wir die Instanzen für den Gurobi Optimizer im lp-Dateiformat zur
Verfügung stellen. CPLEX kann verschiedene Dateiformate einlesen und in weiteren Dateiformaten wieder ausgeben. Zum Konvertieren lesen wir dazu eine Instanz im MINDateiformat mit CPLEX ein und speichern es im lp-Dateiformat. Die Instanzen sind im
lp-Dateiformat generell etwas größer als im MIN-Dateiformat.
Jedes Programm braucht je nach Größe der Instanz eine relativ kurze Zeit um die Datei
einzulesen. Bei der Auswertung ignorieren wir daher in allen Programmen die Einlesezeit und geben nur die Rechenzeit wieder. In der Tabelle jeder Problemklasse geben wir
weiterhin die Größe der erzeugten Datei im MIN-Dateiformat in Megabyte an.
Als erstes betrachten wir die GOTO-8 Problemklasse. Wir werten dabei zehn Instanzen
aus, wobei jede Instanz doppelt so viele Knoten enthält wie die vorherige.
85
5 Vergleich verschiedener Algorithmen
In der GOTO-I Problemklasse werten wir nur sieben Instanzen aus, da die Dateigröße
der Instanzen aufgrund der großen Dichte stark ansteigt und zu einer relativ langen Laufzeit führt. Auch in dieser Problemklasse enthält jede Instanz doppelt so viele Knoten wie
die vorherige.
Bei den Instanzen aus dem GRIDGRAPH Generator beginnen wir mit der GRIDSQUARE Problemklasse. Unsere erste Instanz besteht aus einem 32 mal 32 großen Gitter,
auf dem sich insgesamt 1024 Knoten befinden. Zusätzlich werden eine Quelle und Senke
generiert. Damit die nächste Instanz ungefähr doppelt so viele Knoten enthält, multiplizie√
ren wir die Breite und Höhe des Gitters in jedem Schritt mit 2 und runden den Wert auf
eine ganze Zahl ab oder auf. In den GRID-WIDE und GRID-LONG Problemklassen kann
die Anzahl der Knoten einfacher verdoppelt werden, da die Höhe oder Breite mit 16 bereits
fest vorgegeben ist. Wir brauchen dann nur die variable Seite des Gitters verdoppeln.
Die letzte Instanz der Problemklassen stellt dabei immer das größte Netzwerk mit weniger als einer Million Kanten dar, weil der GRIDGRAPH Generator nicht mehr als eine
Million Kanten erstellen kann. Diese Schranke rührt von der Implementation des Generators her und betrifft auch den NETGEN Generator. Im NETGEN Generator wurde die
letzte Instanz mit 131072 Knoten und nur einer Million Kanten statt eigentlich 1048576
Kanten erstellt. Die Dichte beträgt in der letzten Instanz daher statt 8 nur noch 7, 63.
Als letzten betrachten wir die TCHAIN Problemklasse mit zehn Instannzen und kommen insgesamt auf 65 Instanzen, die getestet werden.
Bei der Auswertung der Instanzen geben wir für jede Problemklasse neben einer logarithmischen Grafik auch eine Tabelle mit den Rechenzeiten der einzelnen Programme an.
Die Zeiten werden in Tagen, Stunden (h), Minuten (m) und Sekunden (s) angegeben. Nur
bei der größten Instanz der GOTO-8 Problemklasse haben die Programme CPLEX und
MCF mehr als 24 Stunden benötigt. Weiterhin konnte der Gurobi Optimizer auf Grund
des begrenzten Arbeitsspeichers von 4 GB nicht alle Instanzen berechnen. Bei diesen Instanzen schreiben wir unter GUROBI den Eintrag Fehler rein.
86
5.3 Auswertung der Instanzen
1,000,000
CPLEX
GUROBI
CS
MCF
100,000
10,000
Zeit in Sekunden
1,000
100
10
1
0.1
0.01
1,000
Knoten
210 = 1024
211 = 2048
212 = 4096
213 = 8192
214 = 16384
215 = 32768
216 = 65536
217 = 131072
218 = 262144
219 = 524288
Größe
0, 422
0, 844
1, 689
3, 375
6, 750
13, 500
27, 000
54, 000
108, 000
216, 000
10,000
Anzahl Knoten
CPLEX
0, 12 s
0, 44 s
2, 63 s
11, 77 s
56, 99 s
4 m 29, 92 s
14 m 45, 63 s
1 h 13 m 59, 55 s
8 h 05 m 34, 87 s
1 Tag und
4 h 46 m 51, 65 s
1
2
5
14
GUROBI
0, 09 s
0, 36 s
1, 75 s
5, 87 s
31, 69 s
m 19, 14 s
m 01, 97 s
m 20, 92 s
m 39, 31 s
Fehler
100,000
CS
0, 04 s
0, 11 s
0, 27 s
4, 25 s
1, 86 s
6, 76 s
16, 93 s
54, 52 s
2 m 06, 26 s
7 m 45, 35 s
MCF
0, 12 s
0, 44 s
2, 42 s
12, 22 s
1 m 08, 26 s
5 m 30, 44 s
27 m 57, 52 s
1 h 58 m 05, 04 s
17 h 42 m 54, 00 s
2 Tage und
22 h 21 m 31, 00 s
Abbildung 5.9: Auswertung der GOTO-8 Problemklasse
87
5 Vergleich verschiedener Algorithmen
100,000
CPLEX
GUROBI
CS
MCF
10,000
Zeit in Sekunden
1,000
100
10
1
0.1
1,000
Knoten
210 = 1024
211 = 2048
212 = 4096
213 = 8192
214 = 16384
215 = 32768
216 = 65536
Größe
1, 688
4, 746
13, 500
37, 969
108, 000
305, 438
864, 000
10,000
Anzahl Knoten
1
8
58
6 h 30
CPLEX
0, 31 s
1, 59 s
12, 06 s
m 13, 28 s
m 54, 83 s
m 09, 90 s
m 02, 31 s
GUROBI
0, 28 s
1, 41 s
8, 71 s
49, 22 s
4 m 35, 29 s
Fehler
Fehler
CS
0, 25 s
0, 40 s
6, 13 s
16, 05 s
2 m 09, 51 s
1 m 31, 72 s
6 m 00, 53 s
Abbildung 5.10: Auswertung der GOTO-I Problemklasse
88
1
11
2 h 23
10 h 32
m
m
m
m
MCF
0, 32 s
1, 72 s
16, 30 s
19, 74 s
13, 00 s
55, 74 s
28, 00 s
5.3 Auswertung der Instanzen
100
CPLEX
GUROBI
CS
MCF
Zeit in Sekunden
10
1
0.1
0.01
1,000
Knoten
2 + 322 = 1026
2 + 452 = 2027
2 + 642 = 4098
2 + 912 = 8283
2 + 1282 = 16386
2 + 1812 = 32763
2 + 2562 = 65538
2 + 3622 = 131046
2 + 5122 = 262146
2 + 7072 = 499851
10,000
Anzahl Knoten
Größe
0, 090
0, 178
0, 360
0, 727
1, 438
2, 875
5, 750
11, 498
23, 000
43, 856
CPLEX
0, 00 s
0, 01 s
0, 02 s
0, 04 s
0, 12 s
0, 32 s
2, 07 s
5.62 s
21, 47 s
1 m 07, 19 s
100,000
GUROBI
0, 02 s
0, 05 s
0, 13 s
0, 20 s
0, 39 s
1, 08 s
2, 58 s
5, 68 s
11, 96 s
24, 86 s
CS
0, 00 s
0, 00 s
0, 00 s
0, 00 s
0, 01 s
0, 02 s
0, 08 s
0, 17 s
0, 39 s
0, 77 s
MCF
0, 00 s
0, 00 s
0, 00 s
0, 02 s
0, 06 s
0, 10 s
0, 50 s
3, 36 s
5, 72 s
14, 08 s
Abbildung 5.11: Auswertung der GRID-SQUARE Problemklasse
89
5 Vergleich verschiedener Algorithmen
1,000
CPLEX
GUROBI
CS
MCF
Zeit in Sekunden
100
10
1
0.1
0.01
1,000
Knoten
2 + 210 = 1026
2 + 211 = 2050
2 + 212 = 4098
2 + 213 = 8194
2 + 214 = 16386
2 + 215 = 32770
2 + 216 = 65538
2 + 217 = 131074
2 + 218 = 262146
2 + 218 · 1, 96881 ≈
516144
10,000
Anzahl Knoten
Größe
0, 088
0, 175
0, 349
0, 697
1, 393
2, 786
5, 571
11, 142
22, 282
43, 868
CPLEX
0, 00 s
0, 01 s
0, 03 s
0, 10 s
0, 31 s
1, 75 s
9, 61 s
45, 03 s
3 m 04, 53 s
22 m 02, 38 s
GUROBI
0, 02 s
0, 06 s
0, 27 s
0, 20 s
0, 41 s
0, 92 s
1, 91 s
4, 32 s
10, 13 s
24, 39 s
100,000
CS
0, 00 s
0, 00 s
0, 00 s
0, 00 s
0, 01 s
0, 03 s
0, 07 s
0, 19 s
0, 39 s
0, 91 s
MCF
0, 00 s
0, 02 s
0, 02 s
0, 06 s
0, 24 s
1, 04 s
9, 48 s
59, 02 s
4 m 16.56 s
18 m 30, 34 s
Abbildung 5.12: Auswertung der GRID-WIDE Problemklasse
90
5.3 Auswertung der Instanzen
CPLEX
GUROBI
CS
MCF
Zeit in Sekunden
10
1
0.1
0.01
1,000
Knoten
2 + 210 = 1026
2 + 211 = 2050
2 + 212 = 4098
2 + 213 = 8194
2 + 214 = 16386
2 + 215 = 32770
2 + 216 = 65538
2 + 217 = 131074
2 + 218 = 262146
2 + 218 · 1, 84955 ≈
484850
10,000
Anzahl Knoten
Größe
0, 092
0, 185
0, 370
0, 741
1, 482
2, 964
5, 929
11, 859
23, 718
43, 868
CPLEX
0, 00 s
0, 01 s
0, 02 s
0, 02 s
0, 05 s
0, 10 s
0, 49 s
3, 16 s
1, 20 s
9, 92 s
100,000
GUROBI
0, 02 s
0, 03 s
0, 06 s
0, 21 s
0, 40 s
0, 93 s
1, 95 s
4, 25 s
9, 43 s
16, 94 s
CS
0, 00 s
0, 00 s
0, 00 s
0, 01 s
0, 01 s
0, 03 s
0, 09 s
0, 23 s
0, 49 s
1, 04 s
MCF
0, 00 s
0, 00 s
0, 00 s
0, 02 s
0, 04 s
0, 08 s
0, 94 s
2, 50 s
5, 14 s
2, 24 s
Abbildung 5.13: Auswertung der GRID-LONG Problemklasse
91
5 Vergleich verschiedener Algorithmen
1,000
CPLEX
GUROBI
CS
MCF
Zeit in Sekunden
100
10
1
0.1
0.01
1,000
Knoten
210 = 1024
211 = 2048
212 = 4096
213 = 8192
214 = 16384
215 = 32768
216 = 65536
217 = 131072
10,000
Anzahl Knoten
Größe
0, 185
0, 387
0, 792
1, 599
3, 307
6, 796
13, 779
28, 080
CPLEX
0, 01 s
0, 04 s
0, 17 s
0, 90 s
4, 30 s
21, 72 s
1 m 47, 93 s
10 m 53, 45 s
GUROBI
0, 03 s
0, 09 s
0, 24 s
0, 87 s
1, 76 s
4, 08 s
9, 54 s
15, 07 s
100,000
CS
0, 02 s
0, 02 s
0, 04 s
0, 13 s
0, 34 s
0, 96 s
2, 60 s
6, 80 s
MCF
0, 00 s
0, 02 s
0, 06 s
0, 30 s
0, 60 s
2, 68 s
14, 44 s
1 m 13, 22 s
Abbildung 5.14: Auswertung der NETGEN Problemklasse
92
5.3 Auswertung der Instanzen
CPLEX
GUROBI
CS
MCF
100
Zeit in Sekunden
10
1
0.1
0.01
1,000
Knoten
210 = 1024
211 = 2048
212 = 4096
213 = 8192
214 = 16384
215 = 32768
216 = 65536
217 = 131072
218 = 262144
219 = 524288
10,000
Anzahl Knoten
Größe
0, 149
0, 323
0, 683
1, 421
3, 007
6, 344
13, 196
27, 411
57, 742
120, 082
CPLEX
0, 01 s
0, 02 s
0, 05 s
0, 09 s
0, 21 s
0, 75 s
1, 71 s
5, 79 s
14, 05 s
46, 21 s
GUROBI
0, 05 s
0, 26 s
0, 78 s
2, 89 s
10, 41 s
42, 16 s
4 m 45, 64 s
Fehler
Fehler
Fehler
100,000
CS
0, 03 s
0, 04 s
0, 10 s
0, 26 s
0, 73 s
2, 59 s
10, 04 s
25, 30 s
1 m 29, 49 s
2 m 32, 41 s
MCF
0, 02 s
0, 02 s
0, 04 s
0, 07 s
0, 20 s
0, 56 s
1, 42 s
3, 78 s
8, 76 s
24, 32 s
Abbildung 5.15: Auswertung der TCHAIN Problemklasse
93
5 Vergleich verschiedener Algorithmen
5.4 Analyse des Auswertung
Wir haben insgesamt sieben Problemklassen ausgewertet. Die Implementation der Generatoren stammt bis auf TCHAIN aus dem Anfang der 90er Jahre. Daher war es mit dem
GRIDGRAPH- und NETGEN-Generator nicht möglich, beliebig große Instanzen zu erstellen. Der GOTO- und TCHAIN-Generator haben alle Instanzen für unsere Auswertung
mit der notwendigen Anzahl an Knoten und Kanten erstellt. Die Dateigröße der Instanzen im MIN-Dateiformat hat bis auf den GOTO- und TCHAIN-Generator nie mehr als 50
Megabyte verbraucht. Beim GOTO-Generator werden in der Datei einer Instanz statt einfacher Leerzeichen Tabulatoren verwendet, was zu einer relativ großen Dateigröße führt.
Bei vergleichbar großen Instanzen verbraucht der GOTO-Generator ungefähr das doppelte
an Speicherplatz.
Wir konnten fast alle Instanzen der Problemklassen mit den vier Programmen auswerten. Der Gurobi Optimizer gibt im Gegensatz zu den anderen drei Programmen am Anfang
der Optimierung an, wie viel Arbeitsspeicher ungefähr gebraucht wird. Bei sechs Instanzen
waren vier Gigabyte Arbeitsspeicher für den Gurobi Optimizer in der Version 4.5 offensichtlich zu wenig. Während in der GOTO-8 Instanz mit 219 Knoten der Gurobi Optimizer
mit der Optimierung begonnen hat und eine Weile später erst abbricht, beginnt er erst gar
nicht die GOTO-I Instanzen mit 215 oder 216 Knoten und TCHAIN-Instanzen mit mehr
als 216 Knoten zu berechnen. Bei den anderen Programmen traten keine vergleichbaren
Fehler auf.
Summieren wir die Laufzeit aller Programme in den einzelnen Problemklassen, so fällt
auf, dass einige Problemklassen schneller zu lösen sind als andere. Um einen aussagekräftigen Vergleich der einzelnen Problemklassen und Programme durchführen zu können,
betrachten wir nur die ersten fünf Instanzen einer Problemklasse. Da der Gurobi Optimizer
in der sechstgrößten Instanz der GOTO-I Problemklasse keine Lösung berechnen konnte,
wäre sonst ein Vergleich nur ohne dieses Programm möglich. Trotzdem ist das Ergebnis für
die Analyse der einzelnen Problemklassen sowohl mit als auch ohne den Gurobi Optimizer
für größere Instanzen dasselbe.
Problemklasse
GRID-LONG
GRID-SQUARE
GRID-WIDE
NETGEN
TCHAIN
GOTO-8
GOTO-I
Summe
CPLEX
0, 10
0, 19
0, 45
5, 42
0, 38
71, 95
622, 07
700, 56
GUROBI
0, 72
0, 79
0, 96
2, 99
14, 39
39, 76
334, 91
394, 52
CS
0, 02
0, 01
0, 01
0, 55
1, 16
6, 53
152, 34
158, 62
MCF
0, 06
0, 08
0, 34
0, 98
0, 35
83, 46
771, 08
856, 35
Summe
0, 88
1, 07
1, 76
9, 94
16, 28
201, 07
1880, 40
2110, 05
Tabelle 5.7: Summe der Laufzeiten in den ersten fünf Instanzen einer Problemklassen in Sekunden
94
5.4 Analyse des Auswertung
Maßgebend für die Laufzeit der ersten fünf Instanzen ist die größte Instanz mit ungefähr
16384 Knoten. Der GRIDGRAPH-Generator erzeugt zusätzlich im Netzwerk eine Quelle
und Senke und hat damit zwei Knoten mehr als die Instanzen in den anderen Generatoren. Alle Programme brauchen zum Lösen der ersten fünf Instanzen der GRID-LONG
Problemklasse insgesamt nicht einmal eine Sekunde. Damit ist GRID-LONG auch die am
schnellsten lösbare Problemklasse für die vier Programme. Die schwierigste Problemklasse
ist offensichtlich GOTO-I. Alle Programme brauchen zum Lösen der ersten fünf Instanzen insgesamt mehr als eine halbe Stunde. Es ist auch die Problemklasse mit der größten
Dichte. Obwohl NETGEN, TCHAIN und GOTO-8 über die gleiche Dichte verfügen, sind
die Instanzen von NETGEN für die getesteten Programme schneller lösbar. Alle Programme brauchen laut der Tabelle 5.7 mindestens das zehnfache der Laufzeit für NETGEN,
um die Instanzen von GOTO-8 zu lösen. Das kann unter anderem mit dem Aufbau des
Netzwerks, als auch mit der weitaus größeren Differenz in den Kapazitäten und Kosten
einer Kante des GOTO-Generators erklärt werden.
Vergleichen wir die Programme, so fällt uns auf, dass der Cost Scaling Algorithmus in allen Problemklassen bis auf die TCHAIN Problemklasse überlegen ist. In 54 von insgesamt
65 Instanzen, die wir ausgewertet haben, ist der Cost Scaling Algorithmus der schnellste
unter allen Programmen. Die einzige Ausnahme außerhalb der TCHAIN Problemklasse
stellt die Instanz des NETGEN-Generators mit 1024 Knoten dar. In dieser Instanz braucht
der Cost Scaling Algorithmus mit zwei Hunderstelsekunden nur eine Hunderstelsekunden
länger als der Netzwerk Simplex Algorithmus von Andreas Löbel, der nur eine Hunderstelsekunde benötigt. In allen zehn Instanzen der TCHAIN Problemklasse konnte der Cost
Scaling Algorithmus nur den dritten Platz hinter CPLEX und MCF belegen. In der zweitgrößten Instanz der Problemklasse GOTO-8 ist der Cost Scaling Algorithmus mehr als
500 mal schneller als der Algorithmus von Andreas Löbel, mehr als 230 mal schneller als
CPLEX und nur fast sieben mal schneller als der Gurobi Optimizer.
Um die Programme anschaulich in allen Problemklassen vergleichen zu können, betrachten wir in der Abbildung 5.16 die Laufzeiten in einer Instanz jeder Problemklasse
mit 16384 Knoten. Die Ergebnisse aus diesen Instanzen sind repräsentativ für alle anderen Instanzen, da die Verhältnisse der Laufzeiten der betrachteten Programme sich auch in
den anderen Instanzen sehr ähneln. Hiermit wird nochmals der Cost Scaling Algorithmus
als schnellstes Programm bestätigt. Der Gurobi Optimizer ist in der Summe das zweitschnellste Programm, braucht aber bei den Instanzen des GRIDGRAPH- und TCHAINGenerators wesentlich länger als CPLEX oder das Programm von Andreas Löbel. Der
GRIDGRAPH-Generator erzeugt jedoch die einfachsten Instanzen und fällt damit in der
Summer der Laufzeiten nicht so sehr ins Gewicht. CPLEX ist in unseren Ergebnissen auf
Platz drei vor dem Programm von Andreas Löbel. Während das Programm von Andreas Löbel bei relativ kleinen Instanzen meistens den zweiten Platz belegt, braucht es für
größere Instanzen verhältnismäßig sehr viel mehr Zeit. Anders sieht es hingegen in der
95
5 Vergleich verschiedener Algorithmen
TCHAIN Problemklasse aus. Dort ist das Programm von Andreas Löbel immer auf Platz
eins, dicht gefolgt von CPLEX.
Insgesamt lässt sich der Cost Scaling Algorithmus als beste Methode zum Lösen von
Minimum Cost Flow Problemen bestätigen. Die anderen drei Programme benutzen zum
Lösen der Probleme eine Implementation des Netzwerk-Simplex-Algorithmus. Dabei ist in
Anbetracht unserer Ergebnisse die beste Implementation im Gurobi Optimizer zu finden.
Der Gurobi Optimizer fällt aber mit dem großen Bedürfnis an Arbeitsspeicher negativ auf.
Um mit dem Netzwerk Simplex Algorithmus sehr große Probleme an einem Computer mit
begrenztem Arbeitsspeicher zu lösen, ist CPLEX unausweichlich. Für sehr kleine Probleme und die TCHAIN Problemklasse ist MCF von Andreas Löbel immerhin der schnellste
Netzwerk-Simplex-Algorithmus. Wahrscheinlich liegt das daran, dass der Gurobi Optimizer und CPLEX vor dem Lösen eines Problems zunächst versuchen, das Problem in eine
bessere Form zu bringen. Dafür werden unter Anderem redundante Variablen und Schranken reduziert. Im Gurobi Optimizer9 und auch in CPLEX10 wird dieser Vorgang presolve
genannt.
9
10
http://www.gurobi.com/doc/45/refman/node597.html
IBM ILOG CPLEX V12.1 Online Manual:
ftp://ftp.software.ibm.com/software/websphere/ilog/docs/optimization/cplex/ps usrmancplex.pdf
96
5.4 Analyse des Auswertung
1,000
CPLEX
GUROBI
CS
MCF
Zeit in Sekunden
100
10
1
0.1
0.01
1
2
Problemklasse
1. GRID-LONG
2. GRID-SQUARE
3. GRID-WIDE
4. NETGEN
5. TCHAIN
6. GOTO-8
7. GOTO-I
Summe
3
CPLEX
0, 05
0, 12
0, 31
4, 30
0, 21
56, 99
534, 83
596, 81
4
Problemklasse
GUROBI
0, 40
0, 39
0, 41
1, 76
10, 41
31, 69
275, 29
320, 35
5
CS
0, 01
0, 01
0, 01
0, 34
0, 73
1, 86
129, 51
132, 47
6
MCF
0, 04
0, 06
0, 24
0, 60
0, 20
68, 26
673, 00
742, 40
7
Summe
0, 50
0, 58
0, 97
7, 00
11, 55
158, 80
1612, 63
1792, 03
Abbildung 5.16: Auswertung der Problemklassen mit 16384 Knoten in Sekunden
97
Anhang
Anhang
TCHAIN Generator in der Programmiersprache C:
/* tchain.out
Copyright Muhammed Alat 2011
Contact form: http://www.muhammed.alat.de/kontakt/
TCHAIN is a min cost flow problem generator in DIMANCS MIN Format.
Compile like: gcc tchain.c -o tchain.out
*/
#include <stdio.h>
#include <stdlib.h>
#define RADIUS 8
#define SEED 2011
int main(argc, argv)
int argc;
char* argv[]; {
if(argc < 3) {
printf("usage : ./tchain.out #nodes #density > filename.min\n");
printf("
#nodes >= 4\n");
printf("
#density >= 2\n");
printf("
#density < nodes\n");
printf("example: ./tchain.out 1024 10 > 10.min\n\n");
exit(0);
}
/* Declare Variables */
long i, j, r, radiusNodes, nodes, density, arcs, tempHead, tempCap, tempCost, dist;
double d;
/* Set nodes ans density */
nodes = (long) atoi( (argv[1]) );
density = (long) atoi( (argv[2]) );
if(nodes < 4 || density < 2 || density >= nodes) {
printf("usage : ./tchain.out #nodes #density > filename.min\n");
printf("
#nodes >= 4\n");
printf("
#density >= 2\n");
printf("
#density < nodes\n");
printf("example: ./tchain.out 1024 10 > 10.min\n\n");
exit(0);
}
/* Set Variables */
srand(SEED);
radiusNodes = 1 + nodes / RADIUS;
density = density - 2;
A
Anhang
long densityArcs[nodes - 1];
arcs = nodes - 1;
d = (double) (2 * density) / (double) (nodes - 1);
/* Compute density for each node */
for(i = 0; i < nodes - 1; i++) {
densityArcs[i] = 1 + (2 * density) - (long) (d * i + 0.5);
arcs = arcs + densityArcs[i];
}
/* Print Network in DIMACS MIN FORMAT */
printf("c TCHAIN Generator\n");
printf("c Seed
= %d\n", SEED);
printf("c Supply
= %ld\n", 2 * nodes);
printf("c Nodes
= %ld\n", nodes);
printf("c Arcs
= %ld\n", arcs);
printf("c Density
= %ld\n", density + 2);
printf("c Radius
= %ld\n", radiusNodes);
printf("p min %ld %ld\n", nodes, arcs);
printf("n 1 %ld\n", nodes);
printf("n %ld -%ld\n", nodes, nodes);
/* Building solution arcs */
for(i = 1; i < nodes; i++) {
printf("a %ld %ld 0 %ld %d\n", i, i + 1, 2 * nodes, 1);
}
/* Building remaining arcs */
for(i = 0; i < nodes - 1; i++) {
for(j = 0; j < densityArcs[i]; j++) {
r = radiusNodes;
if(i + r > nodes - 1) {
r = nodes - 1 - i;
}
dist = rand() % r + 1;
tempHead = dist + i;
d = (double) tempHead / (double) radiusNodes;
tempCap = (rand() % nodes) + 1;
tempCost = rand() % (long) (2 * dist * d + 1);
printf("a %ld %ld 0 %ld %ld\n", i + 1, tempHead + 1, tempCap, tempCost);
}
}
}
B
Abbildungsverzeichnis
2.1
Notation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4
2.2
Ungerichteter Graph . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5
2.3
Digraph . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5
2.4
Netzwerk mit Balancen . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8
2.5
Netzwerk mit Balancen und Kapazitäten . . . . . . . . . . . . . . . . . . . .
9
2.6
Netzwerk mit Balancen, Kapazitäten und Kosten . . . . . . . . . . . . . . . 10
2.7
Minimum Cost Flow Problem und die optimale Lösung
2.8
Residualgraph der Lösung aus Abbildung 2.7 . . . . . . . . . . . . . . . . . 16
2.9
Umformung eines Netzwerks mit negativen Kosten . . . . . . . . . . . . . . 19
. . . . . . . . . . . 14
2.10 Eliminierung der unteren Schranken . . . . . . . . . . . . . . . . . . . . . . 20
2.11 Eliminierung von parallelen Kanten . . . . . . . . . . . . . . . . . . . . . . . 21
3.1
Baumlösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
3.2
Traversierung von T1 aus Abbildung 3.1 . . . . . . . . . . . . . . . . . . . . 32
3.3
Konstruktion eines Hilfsnetzwerks
3.4
Ausgangslösung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
3.5
Berechnung der Knotenpotentiale . . . . . . . . . . . . . . . . . . . . . . . . 43
3.6
Berechnung der reduzierten Kosten . . . . . . . . . . . . . . . . . . . . . . . 43
3.7
Verletzende Kante zum spannenden Baum hinzufügen . . . . . . . . . . . . 47
3.8
Augmentierung vom Kreis . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
3.9
Aktualisierung der Baumstruktur . . . . . . . . . . . . . . . . . . . . . . . . 48
. . . . . . . . . . . . . . . . . . . . . . . 40
3.10 Teilbäume von (V, T ) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
4.1
Ausgangslösung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
4.2
Residualnetzwerk . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
4.3
Reduzierte Kosten nach relabel(1) . . . . . . . . . . . . . . . . . . . . . . . 64
4.4
push(1) mit der zulässigen Kante e13 . . . . . . . . . . . . . . . . . . . . . . 64
4.5
push(1) mit der zulässigen Kante e12 . . . . . . . . . . . . . . . . . . . . . . 65
4.6
1, 5-optimaler b-Fluss . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
5.1
Lösungspfad in der GOTO Instanz . . . . . . . . . . . . . . . . . . . . . . . 78
5.2
Standardkanten im GOTO Netzwerk . . . . . . . . . . . . . . . . . . . . . . 78
5.3
Weitere Kanten im GOTO Netzwerk . . . . . . . . . . . . . . . . . . . . . . 79
5.4
Kanten im GRIDGRAPH Netzwerk . . . . . . . . . . . . . . . . . . . . . . 80
C
Abbildungsverzeichnis
5.5
Skelett im NETGEN Netzwerk . . . . . . . . . . . . . . . . . . . . . . . . . 83
5.6
Restliche Kanten im NETGEN Netzwerk . . . . . . . . . . . . . . . . . . . 83
5.7
Dichte in der TCHAIN Problemklasse . . . . . . . . . . . . . . . . . . . . . 84
5.8
Eine Instanz der TCHAIN Problemklasse . . . . . . . . . . . . . . . . . . . 85
5.9
Auswertung der GOTO-8 Problemklasse . . . . . . . . . . . . . . . . . . . . 87
5.10 Auswertung der GOTO-I Problemklasse . . . . . . . . . . . . . . . . . . . . 88
5.11 Auswertung der GRID-SQUARE Problemklasse . . . . . . . . . . . . . . . . 89
5.12 Auswertung der GRID-WIDE Problemklasse . . . . . . . . . . . . . . . . . 90
5.13 Auswertung der GRID-LONG Problemklasse . . . . . . . . . . . . . . . . . 91
5.14 Auswertung der NETGEN Problemklasse . . . . . . . . . . . . . . . . . . . 92
5.15 Auswertung der TCHAIN Problemklasse . . . . . . . . . . . . . . . . . . . . 93
5.16 Auswertung der Problemklassen mit 16384 Knoten in Sekunden . . . . . . . 97
D
Liste der Algorithmen
1
Berechnung vom Fluss der Baumstruktur . . . . . . . . . . . . . . . . . . . . 34
2
Berechnung vom Potential der Baumstruktur . . . . . . . . . . . . . . . . . . 37
3
Netzwerk Simplex Algorithmus [AMO93, Seite 415] . . . . . . . . . . . . . . 44
4
Cost Scaling Algorithmus [Gol97, Seite 4 und 5] . . . . . . . . . . . . . . . . 62
5
Verfeinerung des Potentials [Gol97, Seite 9] . . . . . . . . . . . . . . . . . . . 72
E
Literaturverzeichnis
[AMO93] Ahuja, Ravindra K. ; Magnanti, Thomas L. ; Orlin, James B.: Network
Flows: Theory, Algorithms, and Applications. Englewood Cliffs, NJ : Prentice
Hall, 1993. – ISBN 013617549X 4, 7, 8, 9, 10, 11, 13, 15, 18, 19, 20, 21, 22, 24,
25, 26, 29, 30, 32, 33, 34, 37, 38, 39, 40, 43, 44, 45, 46, 47, 49, 50, 54, 56, 57, 62,
67, 68, 69, 70, 74, E
[BJG10] Bang-Jensen, Jørgen ; Gutin, Gregory Z.: Digraphs: Theory, Algorithms and
Applications (Springer Monographs in Mathematics). Springer, 2010. – ISBN
085729041X 7, 9, 10, 11, 15, 17, 20, 23, 24
[Dim90]
The Center for Discrete Mathematics and Theoretical Computer Science: The
First DIMACS International Algorithm Implementation Challenge: Problem
Definitions and Specifications.
ftp://dimacs.rutgers.edu/pub/netflow/
general-info/specs.tex. Version: 1990 27
[GK93]
Goldberg, Andrew V. ; Kharitonov, Michael: On Implementing Scaling
Push-Relabel Algorithms for the Minimum-Cost Flow Problem. In: Johnson,
David S. (Hrsg.) ; McGeoch, Catherine C. (Hrsg.): Network Flows and Matching: First Dimacs Implementation Challenge (Dimacs Series in Discrete Mathematics and Theoretical Computer Science) Bd. 12. American Mathematical
Society, 1993, S. 157–198 3, 76, 79
[GNS08] Griva, Igor ; Nash, Stephen G. ; Sofer, Ariela: Linear and Nonlinear Optimization, Second Edition. Society for Industrial Mathematics, 2008. – ISBN
0898716616 2, 12, 13
[Gol94]
Goldberg, Andrew V.: Optimization Algorithms For Large Networks. In:
European Symposium on Algorithms. 1994. – ISBN 354058434X, S. 1–9 2
[Gol97]
Goldberg, Andrew V.: An Efficient Implementation of a Scaling MinimumCost Flow Algorithm. In: J. Algorithms 22 (1997), Nr. 1, S. 1–29 58, 59, 62,
70, 71, 72, 73, 74, 79, E
[GTT90] Goldberg, Andrew V. ; Tardos, Eva ; Tarjan, Robert E.: Network Flow
Algorithms. In: Korte, Bernhard (Hrsg.) ; Lovasz, Laszlo (Hrsg.) ; Promel,
Hans J. (Hrsg.) ; Schrijver, A. (Hrsg.): Algorithms and Combinatorics Bd. 9:
Paths, Flows and VLSI-Layout. Springer-Verlag, 1990, S. 101–164 54
F
Literaturverzeichnis
[Hit41]
Hitchcock, Frank L.: The distribution of a product from several sources to
numerous localities. In: J. Math. Phys., Mass. Inst. Techn. 20 (1941), S. 224–230
2
[IBM09] International Business Machines Corp.:
le formats supported by CPLEX.
IBM ILOG CPLEX V12.1: Fi-
ftp://ftp.software.ibm.com/plex/ps_
reffileformatscplex.pdf. Version: 2009 2, 28
[Joh93]
Johnson, David S. ; McGeoch, Catherine C. (Hrsg.): Network Flows and
Matching: First Dimacs Implementation Challenge (Dimacs Series in Discrete
Mathematics and Theoretical Computer Science). Bd. 12. American Mathematical Society, 1993. – ISBN 0821865986 27
[Jun04]
Jungnickel, Dieter: Graphs, Networks and Algorithms (Algorithms and Computation in Mathematics). second. Springer, 2004. – ISBN 3540219056 4, 5, 6,
7, 10, 11, 12, 14, 22, 25, 26, 29, 30, 35, 36, 38, 40, 42, 49, 50, 52, 53, 60
[Kan39]
Kantorovich, L.V.: Mathematical methods in the organisation and planning
of production. Publication House of the Leningrad State University, Leningrad,
1939. – Translated into english in: Management Science, vol. 6, 1960, 366–422
2
[Kan06]
Kantorovich, L.V.: On the Translocation of Masses. In: Journal of Mathematical Sciences 133 (2006), Nr. 4, S. 1381–1382 2
[Kle67]
Klein, Morton: A primal method for minimal cost flows with applications
to the assignment and transportation problems. In: Management Science 14
(1967), November, Nr. 8, S. 205–220 24
[KNS74] Klingman, D. ; Napier, A. ; Stutz, J: A Program for Generating Large Scale
Capacitated Assignment, Transportation, and Minimum Cost Flow Network
Problems. In: Management Sciences 20 (1974), S. 814–821 81
[KV08]
Korte, Bernhard ; Vygen, Jens: Kombinatorische Optimierung: Theorie und
Algorithmen. Springer, 2008. – ISBN 3540769188 3, 4, 6, 7, 11, 15, 21, 22, 25,
31, 33, 36, 38, 39, 40, 41, 49, 51, 53, 54, 55, 65
[MG49]
M.K. Gavurin, L.V. K.: Primenenie matematicheskikh metodov v voprosakh
analiza gruzopotokov. In: Problemy povysheniia effektivnosti raboty transporta.
Academy of Sciences, U.S.S.R., 1949, S. 110–138 2
[RV93]
Resende, Mauricio G. ; Veiga, Geraldo: An Efficient Implementation of a
Network Interior Point Method. In: Johnson, David S. (Hrsg.) ; McGeoch,
G
Literaturverzeichnis
Catherine C. (Hrsg.): Network Flows and Matching: First Dimacs Implementation Challenge (Dimacs Series in Discrete Mathematics and Theoretical Computer Science) Bd. 12. American Mathematical Society, 1993, S. 299–348 79,
81
[Sch02]
Schrijver, Alexander: On the history of the transportation and maximum
flow problems. In: Mathematical Programming 91 (2002), S. 437–445 2
[Tol30]
Tolstoi, A.N.: Methods of Finding Minimum Total Kilometrage in CargoTransportation Planning in Space. In: Transportation Planning 1 (1930), S.
23–55 2
[Zlo10]
Zlotowski, Oliver: Design, Implementierung und Evaluierung von Netzwerkdatenstrukturen und Netzwerkalgorithmen zum Lösen des Minimum-Cost Flow
Problems. Logos Verlag Berlin, 2010. – ISBN 3832526005 56, 59, 60, 62, 65, 66,
74
[Zul07]
Kapitel 6. In: Zulehner, Walter: Numerische Mathematik: Eine Einführung
anhand von Differentialgleichungsproblemen; Band 1: Stationäre Probleme (Mathematik Kompakt). Birkhäuser Basel, 2007. – ISBN 3764384263, S. 75–77 18
H