Effiziente Algorithmen und Datenstrukturen II

Effiziente Algorithmen und Datenstrukturen II
Sven Kosub
getippt von Martin von Gagern
Sommersemester 2005
2
Organisatorisches
Zu dieser Mitschrift
Ich kann keinerlei Garantie geben, dass diese Mitschrift korrekt ist, geschweige denn vollständig.
Ich behalte mir vor, irgendwann während dem Semester die Lust am Mitschreiben zu verlieren.
Wer einen Fehler irgendeiner Art findet, darf mir diesen gerne mitteilen, ich werde ihn dann
vermutlich korrigieren.
Martin von Gagern
Literatur
• M.T. Goodrich, R. Tamassia:
Algorithm Design: Foundations, Analysis and Internet Examples, 2002
• T.H. Cormen, C.E. Leiserson, R.L. Rivest, C. Stein:
Introduction to Algorithms, 2001
• K. Schöning:
Algorithmik, 2001
Webseite: http://www14.in.tum.de/Lehre/2005SS/ea
Inhaltsverzeichnis
1 Graphenalgorithmen
1.1
1.2
1.3
1.4
7
Datenstrukturen für Graphen . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7
1.1.1
Kantenlisten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7
1.1.2
Adjazenzlisten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8
1.1.3
Adjazenzmatrizen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9
Graphentraversierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9
1.2.1
Tiefensuche (depth-first search) . . . . . . . . . . . . . . . . . . . . . . . .
10
1.2.2
Breitensuche (breadth-first search) . . . . . . . . . . . . . . . . . . . . . .
11
Erreichbarkeitsprobleme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
13
1.3.1
Zweifach zusammenhängender Teilgraph . . . . . . . . . . . . . . . . . . .
13
1.3.2
Starker Zusammenhang . . . . . . . . . . . . . . . . . . . . . . . . . . . .
18
1.3.3
Transitive Hülle
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
20
Minimale Spannbäume . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
21
1.4.1
Kruskal-Algorithmus (1956) . . . . . . . . . . . . . . . . . . . . . . . . . .
22
1.4.2
Prim-Jarnik-Algorithmus (1957 Prim, 1930 Jarnik) . . . . . . . . . . . . .
24
1.4.3
Algorithmus von Boruvka (Boruvka, 1926) . . . . . . . . . . . . . . . . . .
26
1.4.4
Algorithmus von Chazelle (Chazelle, 2000) . . . . . . . . . . . . . . . . .
28
2 Algorithmen für Flüsse und Matchings
41
2.1
Flüsse und Schnitte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
41
2.2
Maximaler Fluss . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
43
2.2.1
46
Algorithmus von Ford und Fulkerson . . . . . . . . . . . . . . . . . . . . .
3
4
INHALTSVERZEICHNIS
2.2.2
Algorithmus von Edmonds und Karp . . . . . . . . . . . . . . . . . . . . .
48
2.3
Maximale Matchings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
49
2.4
Flüsse mit minimalen Kosten . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
51
3 Lineare Programmierung
3.1
3.2
59
Standardformulierungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
59
3.1.1
Beispiele für LP-Modellierungen . . . . . . . . . . . . . . . . . . . . . . .
63
Simplex-Algorithmus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
64
3.2.1
Grundlagen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
64
3.2.2
Formaler Simplex-Algorithmus . . . . . . . . . . . . . . . . . . . . . . . .
67
3.2.3
Terminierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
69
3.2.4
Optimalität und Dualität . . . . . . . . . . . . . . . . . . . . . . . . . . .
71
3.2.5
Initialisierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
75
INHALTSVERZEICHNIS
5
Algorithmen
1
DFS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10
2
BFS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
12
3
EquiClasses . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
17
4
StrongConnectivityTest . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
19
5
Floyd-Warshall . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
20
6
Kruskal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
22
7
Prim-Jarnik . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
24
8
Prim-Jarnik-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
25
9
Boruvka . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
27
10
Minoren-Hierarchie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
34
11
Chazelle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
36
12
Ford-Fulkerson . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
46
13
MinCostFlow . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
57
14
Pivot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
67
15
Simplex . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
69
16
InitializeSimplex . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
76
6
INHALTSVERZEICHNIS
Kapitel 1
Graphenalgorithmen
1.1
Datenstrukturen für Graphen
Implementierung von Graphen
Konvention: n:
m:
1.1.1
Anzahl der Knoten
Anzahl der Kanten
Kantenlisten
• Knotenobjekt für Knoten v ∈ V und Objekt o:
1. Zeiger auf o
2. Zähler für deg(v) bzw. indeg(v) und outdeg(v)
• Kantenobjekt für Kante e ∈ E und Objekt o:
1. Zeiger auf o
2. Markierung für gerichtet“ oder ungerichtet“
”
”
3. Zeiger auf die beteiligten Knoten
Beispiel: A •
5
•B
0
−2
3
4
C
•
−1
•
D
V und E sind jeweils doppelt verkettete Listen; Zeiger weggelassen.
7
8
KAPITEL 1. GRAPHENALGORITHMEN
Komplexitäten von Operationen auf Kantenlisten:
• Bestimmung Knotenanzahl und Kantenanzahl in O(1)
• Bestimmung Knotengrade in O(1)
• Einfügen von Knoten in O(1)
• Einfügen / Löschen von Kanten in O(1)
• Bestimmung inzidenter Kanten an einem Knoten usw. in O(m)
• Adjazenztest in O(m)
• Löschen von Knoten (mit allen inzidenter Kanten) in O(m)
1.1.2
Adjazenzlisten
Erweiterung von Kantenlisten durch Zeiger auf inzidente Kanten
• Knotenobjekt für Knoten v ∈ V und Objekt o:
1. Zeiger auf o
2. Zeiger auf Listen für eingehende und ausgehende Kanten
• Kantenobjekt für Kante e ∈ E und Objekt o:
1. Zeiger auf o
2. Markierung für gerichtet“ oder ungerichtet“
”
”
3. Zeiger auf die beteiligten Knoten
4. Zeiger auf die Position in den Kantenlisten der Knoten
Komplexitäten von Operationen auf Adjazenzlisten
• Bestimmung Knotenanzahl und Kantenanzahl in O(1)
• Bestimmung Knotengrade in O(1)
• Einfügen von Knoten in O(1)
• Einfügen / Löschen von Kanten in O(1)
• Bestimmung inzidenter Kanten an einem Knoten usw. in O(deg(v))
• Adjazenztest in O(min{deg(v), deg(u)})
• Löschen von Knoten (mit allen inzidenter Kanten) in O(deg(v))
1.2. GRAPHENTRAVERSIERUNG
1.1.3
9
Adjazenzmatrizen
Adjazenzmatrix A(G) für Graphen G = (V, E) mit V = {0, . . . , n − 1} ist eine n × n-Matrix mit
(
1 wenn (i, j) ∈ E
aij =
0 wenn (i, j) 6∈ E
Datenstruktur bestehend aus
• Knotenobjekt für Knoten v und Objekt o:
1. Zeiger auf o
2. Index von v; d.h. seine Nummer in V
3. Zähler für Knotengrad deg(v) bzw. indeg(v) und outdeg(v)
• Kantenobjekte wie bei Kantenlisten
• Matrixobjekt als n × n-Array A mit A[i, j] enthält Zeiger auf Kante e = (i, j) (für ungerichtete Graphen: A[i, j] = A[j, i]), sonst Nil
Komplexitäten von Operationen auf Adjazenzmatrizen
• Bestimmung Knotenanzahl und Kantenanzahl in O(1)
• Bestimmung Knotengrade in O(1)
• Einfügen von Knoten in O(n) amortisiert
• Einfügen / Löschen von Kanten in O(1)
• Löschen von Knoten in O(n) amortisiert
• Bestimmung inzidenter Kanten an einem Knoten usw. in O(deg(v))
• Adjazenztest in O(min{deg(v), deg(u)})
• Löschen von Knoten (mit allen inzidenter Kanten) in O(deg(v))
Problem: Für n Knoten stets O(n2 ) Speicherplatz inabhängig von Anzahl tatsächlich vorhandener Kanten
⇒ nur für dichte Graphen sinnvoll
1.2
Graphentraversierung
Traversierung = systemaitisches Ablaufen aller Knoten eines Graphen
10
KAPITEL 1. GRAPHENALGORITHMEN
1.2.1
Tiefensuche (depth-first search)
Tiefensuche produziert zwei Arten von Kanten:
1. Baumkanten
2. Rückwärtskanten
Algorithmus DFS(G, v)
Eingabe: (ungerichteter) Graph G, Knoten v in G
Ausgabe: Markierung der Kanten (in der Zusammenhangskomponente) von v als Baumkante“
”
oder Rückwärtskante“
”
1
2
3
4
5
6
7
8
9
10
11
markiere Knoten v als besucht“
”
for jede Kante e = {u, v}
do
if e nicht markiert
then
Markiere e als Baumkante“
”
DFS(G, u)
else
Markiere e als Rückwärtskante“
”
fi
od
Algorithmus 1: DFS
= Baumkanten
= Rückwärtskanten
A
A
A
B
C
B
A
E
B
C
D
I
D
G
E
H
F
I
E
D
F
H
C
G
B
D
E
F
G
H
G
H
I
I
F
C
Beachte: Die Reihenfolge der Knoteninspektion ist wichtig für die Höhe des DFS-Baumes.
1.2. GRAPHENTRAVERSIERUNG
11
Bemerkungen:
1. Höhe des DFS-Baumes entspricht Platzbedarf der Traversierung (bei Realisierung mit
Stacks)
2. Folgendes Problem ist NP-vollständig (Hamilton-Pfad):
Eingabe: G, k
Frage: Gibt es einen DFS-Baum T für G mit h(T ) ≥ k?
3. Dies gilt auch für die Frage: Gibt es einen DFS-Baum T für G mit h(T ) ≤ k?
Eigenschaften der Tiefensuche (beginnend bei s ∈ V )
1. Tiefensuche besucht alle Knoten der Zusammenhangskomponente von s
2. Baumkanten bilden Spannbaum der Zusammenhangskomponente von s
3. Tiefensuche benötigt O(ms ) Schritte zur Traversierung der Zusammenhangskomponente
von s
Folgende Probleme können mit Tiefensuche in Zeit O(m + n) gelöst werden.
1. Test, ob G zusammenhängend ist
2. Berechnung eines Spannwaldes von G
3. Berechnung aller Zusammenhangskomponenten von G
4. Berechnung eines Pfades zwischen Knoten von G
5. Berechnung eines Kreises in G
1.2.2
Breitensuche (breadth-first search)
Breitensuche produziert zwei Arten von Kanten:
1. Baumkanten
2. Querkanten
12
KAPITEL 1. GRAPHENALGORITHMEN
Algorithmus BFS(G, v)
Eingabe: Graph G, Knoten v in G
Ausgabe: Markierung der Kanten in Zusammenhangskomponente von v als Baumkanten“ oder
”
Querkanten“
”
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
Initialisiere Queue Q
Enqueue(Q, v)
Markiere v als besucht“
”
while Q nicht leer
do
w := Dequeue(Q)
for jede Kante e = {w, u}
do
if e nicht markiert
then
Markiere e als Baumkante“
”
Markiere u als besucht“
”
Enqueue(Q, u)
else
Markiere e als Querkante“
”
fi
od
od
Algorithmus 2: BFS
= Baumkanten
= Querkanten
A1
B4
C7
D2
E3
F9
G5
H8
I6
A
D
E
B
G
I
C
H
F
Eigenschaften der Breitensuche (beginnend bei s ∈ V )
1. Breitensuche besucht alle Knoten in der Zusammenhangskomponente von s
2. Baumkanten bilden Spannbaum in der Zusammenhangskomponente von s
3. Für alle Knoten v der Tiefe i hat Pfad in T von s nach v genau i Kanten und jeder andere
Pfad in G von s nach v mindestens i Kanten.
4. Ist {u, v} Querkante, so unterscheiden sich Tiefen in T um höchstens 1.
5. Breitensuche benötigt O(ms ) Schritte zur Traversierung.
1.3. ERREICHBARKEITSPROBLEME
13
Folgende Probleme können mit Breitensuche in Zeit O(n + m) gelöst werden:
1. Test, ob G zusammenhängend ist
2. Berechnung eines Spannwaldes von G
3. Berechnung aller Zusammenhangskomponenten von G
4. Gegeben Knoten s ∈ V berechne für alle Knoten v ∈ V einen Pfad mit geringster Anzahl
von Kanten
5. Berechnung eines Kreises in G
1.3
Erreichbarkeitsprobleme
1.3.1
Zweifach zusammenhängender Teilgraph
Es sein G ein zusammenhängender ungerichteter Graph.
Ein Artikulationsknoten ◦ ist ein Knoten, nach dessen Entfernung aus G der Graph nicht
mehr zusammenhängend ist.
Eine Brücke (Trennkante)
nicht mehr zusammenhängend ist.
•
•
•
◦
•
•
◦
•
•
ist eine Kante, nach deren Entfernung aus G der Graph
◦
•
Motivation: Artikulationsknoten und Brücken sind kritische Elemente für z.B. Ausfallsicherheit
un Kommunikationsnetzen.
Ein zusammenhängender Graph G ist zweifach zusammenhängend gdw. für alle Knoten u, v
von G gibt es zwei (Knoten-)disjunkte Pfade u und v
Eine zweifach zusammenhängende Komponente von G ist ein Teilgraph G′ , der eine der
folgenden Eigenschaften erfüllt:
1. G′ ist zweifach zusammenhängend und Hinzufügen beliebiger Knoten und Kanten aus G
zu G′ würde zweifach-Zusammenhang zerstören.
2. G′ besteht nur aus einer Brücke in G
Lemma 1:
Es sei G ein zusammenhängender Graph. Dann sind folgende Aussagen äquivalent:
1. G ist zweifach zusammenhängend.
2. Jeweils zwei Knoten von G liegen auf einem Kreis in G.
14
KAPITEL 1. GRAPHENALGORITHMEN
3. G besitzt keine Brücken oder Artikulationsknoten.
Beweis: klar.
Beispiel: Abbildung 1.1 auf Seite 16
Idee:
• Bestimme alle Artikulationsknoten (in O(n2 + nm))
• Bestimme alle Zusammenhangskomponenten in Graph ohne Artikulationsknoten (in O(n+
m))
• Ergänze Knoten zu Komponente geeignet (in O(m2 ))
=⇒ Damit insgesamt O((n + m)2 )
Ziel: Algorithmus, der Zweizusammenhang in O(n + m) bestimmt
Definiere Relation ≡ auf Kantenmenge E von G:
e ≡ f ⇔def e = f oder es gibt einen einfachen Kreis in G (d.h. Kreis ohne doppelte
Knoten), der e und f enthält.
Lemma 2:
Es sei G = (V, E) ein zusammenhängender Graph.
1. Relation ≡ ist eine Äquivalenzrelation auf E
2. Zweizusammenhangskompnenten sind genau die Teilgraphen, die durch Äquivalenzklassen
bzgl. ≡ induziert werden.
3. Kante e ∈ E ist eine Brücke gdw. {e} ist Äquivalenzklasse bzgl. ≡
4. Knoten v ∈ V ist Artikulationsknoten gdw. es gibt zwei Kanten aus unterschiedlichen
Äquivalenzklassen bzgl. ≡, die inzident an v sind.
Beweis: Mit Hilfe von Lemma 1 folgen die Aussagen 2.–4. aus Aussage 1.
Zu 1.
Reflexivität (e ≡ e): aus Definition klar
Symmetrie (e ≡ f ⇒ f ≡ e): klar, da Graph ungerichtet ist.
Transitivität ((e ≡ f ∧ f ≡ g) ⇒ e ≡ g): Es gelte e ≡ f und f ≡ g. Unterscheide drei Fälle:
1. e = g, dann ist die rechte Seite der Implikation wahr, also stimmt die Implikation.
2. e 6= g ∧ (e = f ∨ f = g), dann gibt es einfachen Kreis, der e und g enthält.
3. Es seien nun e, f, g paarweise verschieden. Damit gibt es einfachen Kreis Cef mit e
und f sowie einfachen Kreis Cf g mit f und g. Betrachte Graph Cef ∪ Cf g . Dieser
Graph enthält Kreis mit e und g, der aber im Allgemeinen nicht einfach ist.
1.3. ERREICHBARKEITSPROBLEME
15
zu zeigen: Es gibt stets einen einfachen Kreis Ceg mit e und g.
Es seien pef , qef jeweils die Halbkreise in Cef ; analog seien pgf , qgf definiert.
Für Pfad p = (v0 , v1 , . . . , vk ) sei der Abstand zu Knotenmenge C definiert als
d(p, C) =def min({j|vj ∈ C} ∪ {∞})
Betrachten nun Abstände d(pef , pgf ), d(pef , qgf ), d(qef , pgf ), d(qef , qgf ).
O.B.d.A. sei d(pef , pgf ) minimal; sei vpp der Berührungspunkt. Sei vqq der Berührungspunkt von qef , qgf . Dann ist der Kreis Ceg bestehend aus:
e, pef bis vpp , pgf bis vpp , g, qgf bis vqq , qef bis vqq
einfach und enthält e und g. Damit e ≡ g
Lemma 2 gibt uns einen Ansatz für die Berechnung der Zweizusammenhangskompnenten. Benötigen dazu folgenden Hilfsgraphen H basierend auf einer Tiefensuche in G:
1. V (H) =def E(G), d.h. die Knoten von H sind gerade die Kanten von G.
2. Ist e eine Rückwärtskante von G und sind f1 , . . . , fk die Bauimkanten von G, die zusammen
mit e einen Kreis in G bilden, so gilt: {e, f1 }, . . . , {e, fk } ∈ E(H)
Beachte: Da G genau m − n + 1 Rückwärtskanten besitzt, gilt kE(H)k = O(n · m)
Beispiel: Abbildungen 1.2 bis 1.3 auf der nächsten Seite
Nach Konstruktion von H(G): Die durch Zusammenhangskomponenten von H(G) induzierten
Teilgraphen von G entsprechen genau den Zweizusammenhangskomponenten von G.
Damit ergibt sich folgender Algorithmus für Äquivalenzklassenbestimmung:
1. Traversiere G mittels DFS
2. Berechne H(G) auf Basis der DFS
3. Berechne Zusammenhangskomponenten von H(G), z.B. mittels DFS
4. Gebe für jede Zusammenhangskomponente von H(G) die beteiligten Knoten (d.h. die Kanten von G) aus
Aber: Konstruktion von H(G) benötigt O(n · m) Schritte!
Idee: Berechne lediglich Spannwald von H(G)!
16
KAPITEL 1. GRAPHENALGORITHMEN
•
•
•
•
•
•
•
◦
◦
•
•
◦
•
•
◦
•
•
•
•
•
•
Abbildung 1.1: Zweizusammenhangskomponenten im Graphen G
K1
A19
B18
C16
D15
E14
F20
G17
H7
I8
J13
L2
M21
N6
O9
P12
Q3
R4
S5
T10
U11
Abbildung 1.2: DFS im Graphen G
KL
LQ
HI
QR
IO
TU
RS
OJ
UP
CH
SN
ML
JE
EI
NH
MQ
ED
DH
HG
MR
DC
GM
MN
OT
GB
AG
BA
AF
Kanten, die der Algorithmus EquiClasses nicht ermittelt.
Abbildung 1.3: Hilfsgraph H
PO
FG
1.3. ERREICHBARKEITSPROBLEME
17
Algorithmus EquiClasses(G)
Eingabe: zusammenhängender Graph G
Ausgabe: Zusammenhangskomponenten von H(G)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
H sei leerer Graph
DFS-Traversierung von G beginnend bei beliebigem Knoten s
Füge jede Baumkante f als Knoten in H ein und markiere f als isoliert“
”
for jedes v ∈ V (G) in DFS-Reihenfolge do
for Rückwärtskante e = (u, v) do
Füge e als Knoten in H ein
while u 6= v do
sei f = (Parent(u), u), wobei Elternknoten in DFS-Baum gemeint ist
Füge {e, f } als Kante in H ein
if f isoliert“
”
then Markiere f als verbunden“
”
u :=Parent(u)
else u := v
fi
od
od
od
Bestimme Zusammenhangskomponenten von H
Algorithmus 3: EquiClasses
Komplexität von EquiClass:
O(n + m) für DFS auf G
+ O(m)
für Einfügen aller Baumkanten
+ O(m)
für Spammwaldberechnung (beachte: kV (H)k = m)
+ O(m)
für Berechnung von Zusammenhangskomponenten in H
⇒ O(n + m) Schritte zur Berechnung von Zweizusammenhangskomonenten
von G, Artikulationsknoten und Brücken
Zeile 2
Zeile 3
Zeilen 4-17
Zeile 18
Bemerkung: Zweifacher Zusammenhang läßt sich verallgemeinern: Es sei G(V, E) ein ungerichteter Graph, s, t ∈ V, s 6= t.
λG (s, t) =def
λ(G) =def
κG (s, t) =def
κ(G) =def
minimale Anzahl von Kanten, die aus G
entfernt werden müssen, damit zwischen s
und t kein Pfad mehr existiert.
mins,t∈V,s6=t,{s,t}6∈E λG (s, t)
minimale Anzahl von Knoten, die aus G
entfernt werden müssen, damit zwischen s
und t kein Pfad mehr existiert.
mins,t∈V,s6=t,{s,t}6∈E κG (s, t)
(lokaler Kantenzusammenhang)
(globaler Kantenzusammenhang)
(lokaler Knotenzusammenhang)
(globaler Knotenzusammenhang)
18
KAPITEL 1. GRAPHENALGORITHMEN
Es gilt:
1. κ(G) ≤ λ(G) ≤ δ(G), wobei δ(G) der minimale Grad des Graphen ist.
2. Sind s, t ∈ V nicht benachbart, dann gilt λG (s, t) =maximale Anzahl Knoten-disjunkter
Pfade zwischen s und t (Satz von Menger)
3. Methode zur Bestimmung von λG (st, t) und λG in Kapitel 3 auf Seite 59.
1.3.2
Starker Zusammenhang
Betrachte nun Erreichbarkeit in gerichteten Graphen. Wir sagen: Knoten u erreicht Knoten v
~ falls es einen (gerichteten) Pfad von u nach v gibt.
in G,
~ heißt stark zusammenhängend, falls für alle Knotenpaare u, v ∈ V
Ein gerichteter Graph G
mit u 6= v gilt: u erreicht v und v erreicht u.
Beispiel:
A
C
B
D
F
E
G
~ nicht stark zusammenhängend
• G
• Teilgraph mit {A, B, C, D, F } stark zusammenhängend
Interessieren uns für folgende algorithmischen Probleme:
1. Gegeben u und v bestimme, ob u den Knoten v erreicht.
~ die ein gegebener Knoten s erreicht.
2. Finde alle Knoten von G,
~ stark zusammenhängend ist.
3. Teste, ob G
Lösungsansatz: DFS auf gerichteten Graphen
DFS produziert vier Arten von Kanten:
1. Baumkanten (eines gerichteten DFS-Baumes)
2. Rückwärtskanten (Nichtbaumkanten zu Vorgängern im DFS-Baum)
3. Vorwärtskanten (Nichtbaumkanten zu Nachfolgern im DFS-Baum)
4. Querkanten (Nichtbaumkanten zu Knoten in einem anderen DFS-Teilbaum)
1.3. ERREICHBARKEITSPROBLEME
19
= Baumkanten
= Rückwärtskanten
= Vorwärtskanten
= Querkanten
A4
B3
A1
G
B4
A
E
C5
D6
C
B
E2
C2
D3
E
A
F7
G1
C
F
D
B
F
F5
G
D
Abbildung 1.4: DFS-Traversierung eines gerichteten Graphen
~ ein gerichteter Graph. DFS-Traversierung von G
~ beginnend bei Knoten
Beobachtung: Es sei G
~
s besucht alle Knoten von G, die s erreicht. Insbesondere enthält DFS-Baum einen gerichteten
Pfad von s zu jedem erreichbaren Knoten.
Komplexität von DFS beginnend bei s: O(ns + ms ) Schritte (bei Verwendung von Adjazenzlisten), wobei ns Anzahl der von s erreichbaren Knoten und ms Anzahl der in diesem Teilgraph
enthaltenen Kanten ist.
Folgende Probleme können in O(n2 + n · m) Schritten gelöst werden:
• Bestimme für jeden Knoten v den induzierten Teilgraphen der erreichbaren Knoten.
~ stark zusammenhängend ist.
• Teste, ob G
Aber: Test auf starken Zusammenhang in O(n + m) möglich.
~
Algorithmus StrongConnectivityTest(G)
1
2
3
4
5
6
7
8
9
10
11
Führe DFS auf einem beliebigen Knoten s (z.B. erster Knoten der Knotenliste) aus
if Menge nicht besuchter Knoten nicht leer
then return Nicht stark zusammenhängend“
”
else
~ um
Drehe Orientierung aller Kanten von G
Führe DFS auf umgedrehten“ Graphen auf s aus
”
if Menge nicht besuchter Knoten nicht leer
then return Nicht stark zusammenhängend“
”
else return Stark zusammenhängend“
”
fi
fi
Algorithmus 4: StrongConnectivityTest
20
KAPITEL 1. GRAPHENALGORITHMEN
1.3.3
Transitive Hülle
Ziel: Wollen Zusammenhangs- und Erreichbarkeitsinformationen nach Berechnung festhalten,
d.h. berechnen transitive Hülle.
~ ist der gerichtete Graph G
~ ∗ mit
Transitive Hülle eines gerichteten Graphen G
~ ∗ ) = V (G)
~
• V (G
~ ∗ ) gilt (u, v) ∈ E(G
~ ∗ ) ⇔ u erreicht v in G
~
• Für alle u, v ∈ V (G
Klar: Transitive Hülle kann in O(n2 + n · m) Schritten berechnet werden (mittels wiederholter
DFS)
alternativ: Floyd-Warshall-Algorithmus (1962)
~ ∗ in Runden (V = {v1 , . . . , vn })
Konstruiere G
~
~ 0 =def G
G
~
~ k−1 ∪ (V, {(vi , vj )|(vi , vk ) ∈ E(Gk−1 ) ∧ (vk , vj ) ∈ E(Gk−1 )
Gk =def G
~
Algorithmus Floyd-Warshall(G)
~
Eingabe: gerichteter Graph G
~∗
Ausgabe: transitive Hülle G
1
2
3
4
5
6
7
8
9
10
11
12
13
14
~ 0 := G
~
G
for k := 1 to n do
~ k := G
~ k−1
G
for i := 1 to n do
for j := 1 to n, i 6= j, j 6= k do
~ k−1 ∧ (vk , vj ) ∈ G
~ k−1
if (vi , vk ) ∈ G
~
then if (vi , vj ) 6∈ Gk
~ k hinzu
then Füge (vi , vj ) zu G
fi
fi
od
od
od
~n
return G
Algorithmus 5: Floyd-Warshall
Komplexität von Floyd-Warshall: 3 geschachtelte For-Schleifen ⇒ Θ(n3 ) Schritte (bei Verwendung von Adjazenzmatrizen)
1.4. MINIMALE SPANNBÄUME
1.4
21
Minimale Spannbäume
Betrachte gewichtete ungerichtete zusammenhängende Graphen G. Es sei T ⊆ G ein Spannbaum
von G. Definiere
X
w(e)
w(T ) =def
e∈E(T )
als Gewicht von G. T mit minimalem Gewicht heißt minimaler Spannbaum.
Ziel: Schnelle Algorithmen zur Bestimmung minimaler Spannbäume.
Motivation: Bestimme minimale Leitungslänge, um alle Rechner einer Organisationseinheit
geeignet zu verbinden.
Lemma 3: (blaue Regel)
Es sei G = (V, E, w) ein gewichteter zusammenhängender Graph. Sei V ′ nicht-leere Teilmenge
von V .
1. Ist e ∈ E die einzige Kante mit minimalem Gewicht unter allen Kanten aus
{u, v} ∈ E | u ∈ V ′ , v 6∈ V ′ , so ist e in jedem minimalen Spannbaum enthalten.
2. Ist e ∈ E eine Kante mit minimalem
Gewicht unter allen Kanten aus
{u, v} ∈ E | u ∈ V ′ , v 6∈ V ′ , so gibt es einen minimalen Spannbaum, der e enthält.
Beweis:
1. Übungsaufgabe
2. Sei e ∈ E gewichtsminimale Kante von V ′ nach V \ V ′ . Angenommen e kommt in keinem
minimalen Spannbaum vor. Sei T ein beliebiger minimaler Spannbaum von (V, E, w). Dann
besitzt (V, E(T ) ∪ {e}) einen Kreis C, d.h. es gibt e′ ∈ E(T ) ∩ C von V ′ nach V \ V ′ . Es
gilt jedoch w(e) ≤ w(e′ ). Dann gilt für den Spannbaum T ′ =def (V, E(T ) \ {e′ } ∪ {e}).
w(T ′ ) ≤ w(T ), d.h. T ′ minimaler Spannbaum mit e.
Folgerung 4: Es sei G ein gewichteter zusammenhängender Graph. Sind die Kantengewichte
von G alle verschieden, so ist der minimale Spannbaum eindeutig.
Lemma 5: (rote Regel)
Es sei G = (V, E, w) ein gewichteter, zusammenhängender Graph.
1. Gibt es für eine Kante e ∈ E einen Kreis C in G, der e enthält und für den w(e) > w(e′ )
für alle Kanten e′ ∈ E(C) \ {e} gilt, so kommt e in keinem minimalen Spannbaum vor.
2. Ist C = {e1 , . . . , ek } ein Kreis in G und ist ei ∈ C eine Kante mit w(ei ) ≥ w(ej ) für
1 ≤ j ≤ k, so gibt es einen minimalen Spannbaum, der ei nicht enthält.
Beweis: (Widerspruch)
1. Angenommen es gibt minimalen Spannbaum T von G mit solch einer Kante
e = {u, v} ∈ E(T ). Wenn e aus T entfernt wird, entstehen zwei Teilbäume Tu , Tv mit
22
KAPITEL 1. GRAPHENALGORITHMEN
u ∈ V (Tu ), v ∈ V (Tv ). Da e aber auf Kreis C in G liegt mit w(e) > w(e′ ) für alle e′ 6= e,
gibt es einen Weg in G von u nach v, der e nicht enthält. Dann gibt es auch Kante e′ ∈ E,
die Knoten von Tu mit Knoten von Tv verbindet. Damit ist T ′ =def (V, E(T ) \ {e} ∪ {e′ })
Spannbaum von G mit w(T ′ ) < w(T ). Minimalität von T .
2. Angenommen die beschriebene Kante ei ∈ C = {e1 , . . . , ek } liegt in jedem minimalen
Spannbaum von G. Sei T ein beliebiger minimaler Spannbaum von G. Wenn ei = {u, v}
aus T entfernt wird, entstehen Tu , Tv mit u ∈ V (Tu ), v ∈ V (Tv ). Analog zu 1. können
wir ei durch jede Kante ej ∈ C ersetzen, die Tu mit Tv verbindet. Dann ist T ′ =def
(V, E(T ) \ {ei } ∪ {ej }) Spannbaum von G ohne ei . Außerdem gilt: w(T ′ ) ≤ w(T ) wegen
w(ei ) ≥ w(ej ). D.h. T ′ minimaler Spannbaum.
1.4.1
Kruskal-Algorithmus (1956)
Idee: Wähle iterativ Kante mit minimalem Gewicht unter Beachtung der Kreisfreiheit. (Korrektheit folgt direkt aus der blauen Regel, Lemma 3 auf der vorherigen Seite)
Verwenden zur Implementierung
• Priority Queues
• Union-Find-Strukturen
Algorithmus Kruskal(G)
Eingabe: gewichteter zusammenhängender Graph G = (V, E, w) mit n Knoten und m Kanten
Ausgabe: Minimaler Spannbaum T
1
2
3
4
5
6
7
8
9
10
11
12
13
14
for v ∈ V do
MakeSet(v)
od
Initialisiere Priority Queue Q mit allen Kanten und Kantengewichten als Schlüssel
E(T ) := ∅
while kE(T )k < n − 1 do
{u, v} := ExtractMin(Q)
r1 := Find(u)
r2 := Find(v)
if r1 6= r2
then E(T ) := E(T ) ∪ {u, v}
Union(r1 , r2 )
fi
od
Algorithmus 6: Kruskal
Beispiel: Abbildung 1.5 auf der nächsten Seite
1.4. MINIMALE SPANNBÄUME
23
Kante noch in Queue
r1 6= r2 , in Spannbaum
r1 = r2 , nicht im Spannbaum
A
A
1
8
2
E
1
B
9
6
D
8
2
5
7
3
4
6
D
8
9
3
6
D
8
2
B
9
6
D
4
4
B
9
C
10
8
2
7
3
6
D
4
C
10
1
5
E
B
7
A
1
5
7
3
E
C
10
5
A
1
E
B
9
3
8
2
7
A
2
1
5
E
C
10
A
4
E
B
7
9
3
C
10
5
6
D
4
C
10
Abbildung 1.5: Algorithmus von Kruskal
Kante, die noch nicht betrachtet wurde
Kante e, die durch ExtractMin erhalten wird
Kanten, die bereits im Spannbaum sind
A0
A
1
8
2
E∞
3
1
5
B∞
7
6
D∞
4
E1
3
E
10
2
B6
6
10
C5
4
E
6
8
1
C5
10
8
2
5
B4
6
10
4
A
9
D
B7
9
3
D2
7
3
5
7
C5
1
5
9
D
4
E
A
8
7
3
B8
6
D2
8
2
9
A
1
2
1
5
7
C∞
10
8
2
9
A
C
4
E
5
B
7
3
9
D
Abbildung 1.6: Algorithmus von Prim und Jarnik
6
10
C
24
KAPITEL 1. GRAPHENALGORITHMEN
Komplexität von Kruskal:
Zeilen 1–3:
O(n)
Zeile 4:
O(m)
Zeilen 6–14:
maximal m Durchläufe der while-Schleife
Zeile 7:
O(log m)
Zeilen 8–9:
O(log∗ n) amortisiert
Zeile 12:
O(log∗ n) amortisiert
=⇒
O(m log m) = O(m log n) Schritte
1.4.2
Prim-Jarnik-Algorithmus (1957 Prim, 1930 Jarnik)
Dijkstra-ähnliche“ Idee: Beginne mit einer leeren Knotenmenge und ziehe dann stets den Kno”
ten in die Menge, der leichteste Kante zu irgendeinem Knoten der Menge hat. (Korrektheit folgt
aus der blauen Regel, Lemma 3 auf Seite 21)
Algorithmus Prim-Jarnik(G)
Eingabe: gewichteter zusammenhängender Graph G = (V, E, w) mit n Knoten und m Kanten
Ausgabe: Minimaler Spannbaum T
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
D[v] := 0 (für gewähltes v ∈ V )
for u ∈ V \ {v} do
D[u] := +∞
od
T := (∅, ∅)
Initialisiere Priority Queue Q mit Objekten ((u, Nil), D[u]) für alle u ∈ V und Schlüssel D[u]
while Q nicht leer do
(u, e) := ExtractMin(Q)
T := T ∪ {(u, e)}
; e ist Kante
for Nachbar z von u mit z ∈ Q do
if w(u, z) < D[z]
then D[z] := w(u, z)
Aktualisiere D[z] in Q (DecreaseKey)
Aktualisiere (z, (u, z)) für z ∈ Q
fi
od
od
return T
Algorithmus 7: Prim-Jarnik
Komplexität von Prim-Jarnik (mit Fibonacci-Heaps):
1.4. MINIMALE SPANNBÄUME
Zeilen 1–6:
Zeilen 7–17:
25
O(n)
Für jeden Knoten u ∈ V ein Durchlauf der while-Schleife
Zeile 8:
O(log n) amortisiert
Zeilen 10–16: O(deg(u)) amortisiert
!
X
⇒ O
(log n + deg(u)) = O(n log n + m)
u∈V
⇒
O(n log n + m) Schritte
Zweiter Algorithmus von Prim-Jarnik (nach Fredman, Tarjan, 1987)
Idee: Beschränkiung der Größe der Priority Queues
Algorithmus Prim-Jarnik-2(G)
Eingabe: gewichteter zusammenhängender Graph G = (V, E, w)
Ausgabe: Minimaler Spannbaum T
1
2
3
4
5
6
7
8
9
10
11
12
13
while kV k > 1 do
t := 0
T := ∅
while V 6= T
t := t + 1
Wähle zt aus V \ T
Baue Baum Tt mit Hilfe von Prim-Jarnik nur mit Knoten aus V \ T auf,
so lange bis Priority Queue Qt mehr als r Elemente enthält (beachte:
Element wird erst in Qt eingefügt, wenn Schlüssel verschieden von ∞
ist)
T := T ∪ Tt
od
V := {1, . . . , t}
E := {i, j}|1 ≤ i, j ≤ t, i 6= j und es gibt Kante von Knoten aus Ti zu Knoten aus Tj
w(i, j) := min w(u, v) für {i, j} ∈ E, u ∈ T, v ∈ Tj , u, v benachbart
od
Algorithmus 8: Prim-Jarnik-2
Komplexität einer möglichen Implementierung:
Zeilen 2–9:
O(t · log r + m) bei Realisierung mit Fibonacci-Heaps;
t Anzahl der Knoten vor Durchlauf
Zeilen 10–12: O(m)
mit baumbasierten Union-Find-Strukturen
(Union-Operationen vor Find-Operationen)
Problem: Wie ist r zu wählen?
• Ist r klein, dann Zeit pro Durchlauf klein
• Ist r groß, dann Anzahl der Durchläufe klein
Setze r =def 2
2m/t
, t Anzahl der Knoten vor Durchlauf
26
KAPITEL 1. GRAPHENALGORITHMEN
•
T1
•
•
•
•
•
•
•
T3
•
1
•
•
T2
2
3
•
•
•
7
•
6
•
5
4
•
1
T1
3
T3
T2
1
•
•
T2
2
3
•
•
•
•
7
•
•
•
•
•
T4
6
T3
•
T1
•
•
•
•
•
4
6
T4
T4
5
4
Abbildung 1.7: Algorithmus von Prim und Jarnik nach Fredman und Tarjan
=⇒
O(m) Schritte pro Durchlauf
Bestimmen Anzahl t′ der Bäume, die nach einem Durchlauf verbleiben auf Graphen mit t Knoten
und m′ Kanten:
t′ ≤
2m′
r
Begründung:
• Jeder Baum Ti ist mit mindestens r Kanten inzident, die einen Knoten in Ti haben.
• Jede Kante verbindet genau zwei Knoten.
2m
t′
2m
≥ 2 2m′ ·r ≥ 2r
2m
Zu Beginn: kV k = n ≥
n
=⇒ Anzahl Durchläufe (while-Schleife in Zeile 1) ≤ min{i | log log . . . log n ≤ 1} = log∗ n
{z
}
|
Damit: r′ = 2
=⇒ Prim-Jarnik-2 läuft in O(m · log∗ n)
1.4.3
i
Algorithmus von Boruvka (Boruvka, 1926)
Idee: Verteilte Version von Prim-Jarnik; lasse viele Bäume (Cluster, Superknoten) gleichzeitig
wachsen (bis sie sich berühren).
1.4. MINIMALE SPANNBÄUME
27
Kante, die noch nicht betrachtet wurde
Kante, die gerade betrachtet wird
Kanten, die bereits im Spannbaum sind
A
A
1
E
3
5
B
9
6
10
E
4
C
3
5
B
9
6
10
8
2
7
D
1
8
2
7
D
1
8
2
A
C
4
E
3
5
B
7
9
D
6
10
4
C
Abbildung 1.8: Algorithmus von Boruvka
Algorithmus Boruvka(G)
Eingabe: gewichteter zusammenhängender Graph G = (V, E, w)
Ausgabe: Minimaler Spannbaum T
1
2
3
4
5
6
7
8
T := (V, ∅)
while kE(T )k < n − 1 do
for Zusammenhangskomponente Ci von T do
Bestimme leichteste Kante e = {u, v} ∈ E mit u ∈ Ci , v 6∈ Ci
E(T ) := E(T ) ∪ {e}
od
od
return T
Algorithmus 9: Boruvka
Korrektheit des Algorithmus folgt aus der blauen Regel, Lemma 3 auf Seite 21 (bis auf Behandlung von Tie-Breaks).
Implementierungsaspekte:
• Datenstruktur für Verwaltung des Waldes T unter Kanteneinfügung (⇒ O(1) Schritte pro
Einfügung)
• Nach jedem Durchlauf von Zeilen 3–6 folgt Traversierung von T mittels Tiefensuche (⇒
O(n) Schritte)
• Zur Bestimmung leichtester Kanten Adjazenzliste
28
KAPITEL 1. GRAPHENALGORITHMEN
Komplexität einer möglichen Implementierung:
Zeilen 3–6:
Traversierung von T in O(n)
Bestimmung leichtester Kanten in O(m)
⇒ O(n + m) = O(m) Schritte
Anzahl Durchläufe: Jede neue Kante vereinigt zwei Zusammenhangskomponenten. D.h.
nach jedem Durchlauf höchstens Hälfte der Komponenten noch vorhanden ⇒ O(log n) Durchläufe
Damit O(m log n) Schritte für Boruvka
1.4.4
Algorithmus von Chazelle (Chazelle, 2000)
Betrachten noch einmal einen Boruvka zu unserem Beispiel:
A
ABCDE
1
8
2
E
3
5
5
1
9
6
10
C
BC
ADE
B
7
D
5
2
1
1
4
4
A
D
E
B
C
Boruvka-Algorithmus produziert Hierarchie bei Berechnung des minimalen Spannbaums bottom”
up“.
Beobachtung: Wenn wir Hierarchie wüssten, dann könnten wir auch Spannbaum leicht berechnen.
Idee: Berechne Hierarchie top-down“!
”
Es sei G = (V, E, w) ein gewichteter, ungerichteter zusammenhängender Graph. Vereinfachung:
Alle Kantengwichte verschieden.
MST(G) bezeichne eindeutigen minimalen Spannbaum von G.
Eine Knotenmenge U ⊆ V heißt kontrahierbar gdw. G[U ] ∩ MST(G) zusammenhängend.
(G[U ] =
b durch U induzierter Teilgraph von G)
Es sei e = {x, y} ∈ E. Dann heißt der Graph G/e = (V ′ , E ′ ) Kontraktion von G nach e, falls
V ′ =V \ {x, y} ∪ {ve }
E ′ = {u, v} ∈ E | {u, v} ∩ {x, y} = ∅
∪ {u, ve } | {x, u} ∈ E \ {e} oder {y, u} ∈ E \ {e}
Es sei[X ein weiterer ungerichteter Graph und {Vx | x ∈ V (X)} eine Partition von V , d.h.
V =
Vx und Vx ∩ Vy = ∅ für x 6= y, mit folgender Eigenschaft: G[Vx ] zusammenhängend für
x
alle x ∈ V (X).
G heißt Minor von X ged. für alle x, y ∈ V (X) gilt: {x, y} ∈ E(X) ⇔es gibt u ∈ Vx , v ∈ Vy mit
1.4. MINIMALE SPANNBÄUME
29
{u, v} ∈ E
Beispiel:
X:
Minor von X:
1
2
kein Minor von X:
•
1
257
6
7
3
5
4
34
•
6
•
•
•
G heißt zulässiger Minor von X falls Vx kontrahierbar für alle x ∈ V (X)
Proposition 6: Es seien G und X ungerichtete zusammenhängende Graphen. G ist Minor von
X gdw. X kann durch Kantenkontraktion aus G gewonnen werden.
Beweis: klar
Betrachten Minoren-Hierarchie H, d.h. Graphenfolge (X0 , X1 , . . . , Xα ) mit X0 = G, Xi ist
zulässiger echter Minor von Xi+1 für 0 ≤ i ≤ α − 1 und Xd besteht nur aus einzelnem Knoten.
H kann aufgefasst werden als balancierter Baum, d.h. Blätter liegen auf gleichem Level. Höhe
von H ist d.
Es sei z ∈ V (Xi ). Zu z korrespondiert in H eine Menge Vz ⊆ V (Xi−1 ). Insbesondere hat z in H
genau kVz k Kinder.
Zur Berechnung von MST(G) berechne rekursiv beginnend bei Wurzel von H für alle Knoten z
in H MST(G[Vz ]) und vereinige“ alle Minimalen Spannbäume.
”
1
2
A
B
C
D
4
3
7
E
9
F
I
15
M
16
22
H
13
12
J
6
8
G
11
10
14
5
K
19
L
18
17
21
20
N
23
O
24
P
X4
A...P
X3
CDGHKLOP
ABEF IJM N
X2
IM
ABEF
X1
AB
X0
A
EF
B
E
F
JN
CDGH
I
M
J
N
CD
I
M
J
N
C
KP
GH
D
G
H
LO
K
P
L
O
K
P
L
O
30
KAPITEL 1. GRAPHENALGORITHMEN
1
A
B
4
3
7
E
I
15
M
A
K
N
23
B
7
E
15
M
14
11
K
D
A
N
23
L
X4
16
15
M
P
24
14
22
A...P
X3
ABEF IJM N
X2
ABEF
9
IM
4
4
10
CDGH
13
12
18
JN
14
CDGHKLOP
21
KP
LO
22
X1
AB
CD
4
3
EF
9
I
15
M
14
16
22
10
GH
11
J
17
N
5
13
12
K
19
L
18
21
20
23
O
24
P
6
H
13
12
K
L
19
21
20
23
O
C
24
2
4
11
P
D
5
G
J
N
8
18
F
17
D
5
G
11
B
10
I
21
O
7
E
9
20
N
3
H
19
22
1
2
4
J
17
6
18
17
22
M
13
12
J
16
8
15
P
5
G
10
I
24
2
C
F
9
O
16
C
F
10
14
I
21
4
3
E
L
20
B
3
7
9
18
17
22
1
6
H
19
1
A
13
12
J
16
8
G
11
10
14
D
5
F
9
2
C
8
6
H
13
12
K
19
L
18
21
20
23
O
24
P
1.4. MINIMALE SPANNBÄUME
31
Problem: Wie können wir kontrahierbare Teilmengen entdecken, ohne MST zu berechnen?
vorläufige Antworten:
• Verwende Soft Heaps
• Verwende rote Regel (Lemma 5 auf Seite 21)
• Traversiere H in Postorder (berechne dafür Hierarchien für Graphen G[Vz ] rekursiv neu)
Werden zeigen:
(*) Für Graphen mit n Knoten und m Kanten kann eine Hierarchie der Höhe d in O(m+d3 ·n)
Schritten berechnet werden.
Wir können Höhe selbst wählen (keine Konstante!)
• d groß ⇒ nz klein (nz = kVz k)
• d klein ⇒ nz groß
Geschickte Wahl: Es sei dz die Tiefe von z in H, d.h. die Anzahl der Kanten auf Pfad in H
bis Blatt unterhalb von z.
Definiere die Anzahl der Verzweigungen eines Knotens als

3

für dz = 1
s(t, 1)
nz =def s(t − 1, s(t, dz − 1))3 für dz > 1


0
für dz = 0
mit
t = min{i > 0 | n ≤ s(i, d)3 }
1 m /3
d=c
n
und
s(1, j) = 2j
für i > 0
s(i, 1) = 2
für i > 0
s(i, j) = s(i, j − 1) · s(i − 1, s(i, j − 1))
s(i, 0) = 0
für i, j > 1
für i > 0
Für Knoten z in H sei die Expansion von z in H, bezeichnet mit ξ(z), die Anzahl der Blätter
in H unterhalb von z, d.h. die Anzahl der Knoten in G, die zu z kontrahiert werden.
Proposition 7: Es gilt ξ(z) = s(t, dz )3 für alle z in H (falls n = s(t, d)3 )
32
KAPITEL 1. GRAPHENALGORITHMEN
Beweis: Induktion über dz
Induktionsannahme: Fall dz = 0 klar. Für dz = 1 gilt ξ(z) = nz = s(t, 1)3
Induktionsschritt: Es sei dz > 1. Dann gilt
ξ(z) =
X
ξ(z ′ )
z ′ Kind von
z in H
= nz · s(t, dz − 1)3
= s(t − 1, s(t, dz − 1))3 · s(t, dz − 1)3
= s(t, dz )3
Komplexität von Algorithmus“ von Chazelle mit (*) auf der vorherigen Seite:
”
Vereinfachung: n = s(t, d)3
Zu zeigen: Algorithmus von Chazelle benötigt B · t · (m + d3 n) Schritte zur MST-Berechnung
in Graphen mit m Kanten und n Knoten (B groß genug).
Induktion über t.
Induktionsannahme: t = 1: D.h. n = s(1, d)3 = (2d)3 = 8d3 ≤ 8c̃ ·
2
2
m
n
1/3 3
Damit gilt
n ≤ 8 · c̃ · m. Verwende Boruvka-Algorithmus in der O(n ) Version (Übung) um den MST zu
berechnen. Damit A · n2 ≤ 8| · {z
c̃ · A} ·m ≤ B · t · (m + d3 n) Schritte.
≤B
Induktionsschritt: Es sei t > 1. Damit nimmt die Induktionsvoraussetzung folgende Gestalt an
(z innerer Knoten in H unterhalb der Wurzel):
Induktionsvoraussetzung: MST für mz Kanten, nz Knoten und Tiefe dz benötigt B · (t − 1) ·
(mz + s(t, dz − 1)3 · nz ) Schritte wegen nz = s(t − 1, s(t, dz − 1))3
(dz > 2)
Für die Berechnung von MST(G) benötigen wir dann höchstens (ohne Vorberechnung von H)
≤
X
z∈H
B · (t − 1) · (mz + s(t, dz − 1)3 · nz )
=B · (t − 1) ·
=B · (t − 1) ·
=B · (t − 1) ·
Prop. 7
Jedes Blatt höchstens
in d Expansionen
=B · (t − 1) ·
m+
X
z
m+
X
z
m+
X
3
s(t, dz − 1) nz
3
m+
3
s(t, dz − 1) s(t − 1, s(t, dz − 1))
3
s(t, dz )
z
X
!
!
ξ(z)
z
=B · (t − 1) · (m + d · n)
!
!
1.4. MINIMALE SPANNBÄUME
33
Inklusive Vorberechnung ergeben sich damit höchstens
B · (t − 1)(m + dn) + B(m + d3 n) ≤ B · t(m + d3 n) Schritte
Wie groß ist O(t · (m + d3 · n)) gemessen an n und m?
Definieren Ackermann-Funktion und ihr Inverses:


2j
A(i, j) =def 2


A(i − 1, A(i, j − 1))
für i = 0, j ≥ 0
für i > 0, j = 1
für i > 0, j > 1
Es gilt:
• A(0, n) = 2n
• A(1, n) = A(0, A(1, n − 1)) = 2 · A(1, n − 1) = 2n
o
···2
n
• A(2, n) = A(1, A(2, n − 1)) = 2A(2,n−1) = 22
···2
• A(3, n) = A(2, A(3, n − 1)) = 22
o
A(3, n − 1)
Inverse“ Ackermann-Funktion nach Tarjan:
”
i
α(i, j) =def min k ≥ 1 | A k, 4
> log j
j
Lemma 8:
l
Es sei G ein Graph mit m Kanten und n Knoten. Für d = c·
gilt t = O(α(m, n)).
m
n
1/3 m
und t = min i > 0 | n ≤ S(i, d)3
Beweis: Mit A(i, j) ≥ 2j+1 für i ≥ 2, j ≥ 3 gilt für i ≥ 1, j ≥ 4:
A(3i, j) = A(3i − 1, A(3i, j − 1)) ≥ A(3i − 1, 2j ) ≥ A(i, 2j )
(1.1)
Außerdem gilt für i ≥ 1, j ≥ 4:
A(3i, j) = A(3i − 1, A(3i, j − 1)) ≥ 2A(3i,j−1) = 2A(3i−1,A(3i,j−2)) ≥ 2A(i,j)
(1.2)
Damit:
(1.2)
(1.1)
d
S(9α(m, n) + 1, d) ≥ A(9α(m, n), d) ≥ 2A(3α(m,n),d) ≥ 2A(α(m,n),2
c groß
)
≥ 2A(α(m,n),4·⌈ n ⌉) > 2log n = n
m
D.h. kleinstes t mit n ≤ S(t, d)3 erfüllt auch t ≤ 9α(m, n) + 1
Jetzt: Hierarchie-Berechnung
Berechne Hierarchie der Höhe d mit den spezifizierten Parametern n, nz usw. in PostorderReihenfolge über den Graphen G. Zunächst noch ohne Soft-Heaps.
34
KAPITEL 1. GRAPHENALGORITHMEN
Algorithmus Minoren-Hierarchie(z, az )
Eingabe: Knoten z in H mit Tiefe dz
Ausgabe: Knotenmenge Vz und Priority Queue aller Schnittkanten
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
if dz = 0
then Vz := {z}
Initialisiere Priority Queue Qz aller zu z inzidenten Kanten in X0 = G
return (Vz , Qz )
else
while kVz k < nz do
if kVz k = 0 . . . fi
in Vorlesung nicht weiter erklärt
{u, v} := ExtractMin(Qz )
(o.B.d.A. u ∈ Vz ; beachte: {u, v} ∈ E(Xdz ))
(Vv , Qv ) := Minoren-Hierarchie(v, dz − 1)
Kontrahiere Vv in Xdz −1 → Xdz
Vz := Vz ∪ {v}
Entferne aus Qv alle Kanten, die inzident zu Vz sind
Qz := Qz ∪ Qv
od
return (Vz , Qz )
fi
Algorithmus 10: Minoren-Hierarchie
Erinnerung:
1. Soft Heap ist Datenstruktur, die Operationen
• Insert(o, k), Merge(Q1 , Q2 ), Delete(k) amortisiert in O(1) Schritten
• ExtractMin amortisiert in O(log 1ε ) Schritten
unterstützt und zu jedem Zeitpunkt höchstens ε · n verdorbene Schlüssel enthält, wibei n
die Gesamtzahl der Einfügungen ist.
2. verdorbene Schlüssel haben einen höheren Schlüsselwert als ursprünglich.
Problem bei Verwendung von Soft Heaps: Es können die falschen Kanten aus Priority Queue
herausgezogen werden, d.h. Kanten müssen nicht minimale Gewichte besitzen. Damit ist blaue
Regel (Lemma 3 auf Seite 21) nicht mehr anwendbar für Korrektheit.
Sei H die zu traversierende Minorenhierarchie. Es sei z der aktuell besuchte Knoten in H. Ein
Pfad (z1 , . . . , zk ) in H heißt aktiv gdw. z1 ist Wurzel (dz1 = d) und zk = z. (Vz1 , . . . , Vzk ) sind
die zugehörigen Knotenmengen; ist zi+1 linkes Kind von zi in H, dann ist Vzi = ∅.
Eine Kante e ∈ E(G) heißt Schnittkante bzgl. (z1 , . . . , zk ) gdw. e ist inzident zu genau einem
Knoten in Vz1 ∪ · · · ∪ Vzk
Klar: Status von Kanten als Schnittkanten ändert sich im Zeitlauf.
Eine Kante e = {u, v} heißt kritisch, gdw. e ist Schnittkante mit verdorbenem Gewicht, d.h. e
ist in einem Soft Heap H mit w(e) < key H (e), u ∈ Vz und Vz wird kontrahiert.
1.4. MINIMALE SPANNBÄUME
35
Wir halten Informationen über Beziehungen der Vz1 , . . . , Vzk entlang eines aktiven Pfades (z1 , . . . , zk )
aufrecht:
Invariante 1:
Für alle 1 ≤ i < k besteht Kettenlink c(Vzi , Vzi+1 ) aus Kante e, deren aktuelle Kosten wakt (e)
(Schlüsselwert von e in einem Soft Heap) folgende Eigenschaften erfüllen:
1. wakt (e) ≤ wakt (f ) für alle Schnittkanten bzgl. Vz1 ∪ · · · ∪ Vzi
2. wakt (e) ≤ wwork (i, j) für alle 1 ≤ j < i mit
(
wakt (f ) , f kritisch
wwork (f ) =
w(f )
, sonst
und wwork (i, j) = min{wwork (f ) | f ∈ E(Vzi , Vzj )}
Bemerkung: Invariante 1 garantiert Kontrahierbarkeit.
Invariante 2:
Für alle 1 ≤ j ≤ k und für alle Schnittkanten e = {u, v} mit u ∈ Vzj gilt: e ist genau in einem
der Soft Heaps H(j) oder H(i, j) mit 1 ≤ i < j enthalten. Außerdem gilt:
• e ∈ H(j)
⇒
es gibt w mit {v, w} ∈ H(i, j) für 1 ≤ i < j
• e ∈ H(i, j) ⇒ es gibt w ∈ Vzi mit {v, w} ∈ E(G) aber für alle w ∈ Vzi+1 ∪ · · · ∪ Vzj−1
gilt {v, w} 6∈ E(G)
Bemerkung: Invariante 2 wird zur Kontrolle kritischer Kanten verwendet.
Betrachten nun Operationen Retraction ind Extension zur Traversierung von H.
1. Retraction (=
b Pop auf Rekursionsstack)
Sei (z1 , . . . , zk ) aktiver Pfad. Folgendes wird ausgeführt:
(a) Kontrahiere Vzk und neuer Knoten v̂k wird in Vzk−1 aufgenommen.
(b) Aktualisiere Kettenlink c(Vzk−1 , Vzk )
Invarianten:
• Invariante 1: klar
• Invariante 2:
→ O(k) Schritte
(a) Soft Heaps H(k), H(k − 1, k) werden zerstört
(b) alle verdorbenen Kanten werden entfernt
(c) verbleibende Kanten werden entsprechend ihrer Endpunkte partitioniert, d.h. in
Mengen Pv mit gleichem Endpunkt v eingeordnet.
(d) für alle Pv wähle Kante e mit minimalem Gewicht und eliminiere alle anderen
Kanten aus G.
(e) füge Kanten ev in entsprechenden Soft Heap ein
36
KAPITEL 1. GRAPHENALGORITHMEN
(f) Verschmelze H(i, k) mit H(i, k − 1)
2. Extension (=
b Push auf Rekursionsstack)
Sei (z1 , . . . , zk ) aktiver Pfad. Folgendes führen wir aus:
(a) Führe ExtractMin auf allen Soft-Heaps aus; sei e = {u, v} Kante mit minimalem
aktuellem Gewicht; e heißt Erweiterungskante.
(b) Bestimme i∗ = min 1 ≤ i ≤ k es gibt i < j ≤ k mit wwork (i, j) ≤ wakt (e) ∪ {∞}
Falls i∗ < ∞ führe Fusion aus:
Es sei f Kante mit wwork (I ∗ , j ∗ ) = wwork (f ) ≤ wakt (e); es sei außerdem a ∈ Vzi∗
der zu f inzidente Knoten. Kontrahiere alle Knotenmengen Vzi∗ +1 , . . . , Vzk in a (wie
bei Retraction, aber ohne Einfügen neuer Kanten).
(c) Vzk∗ := {v} und der Kettenlink zwischen Vzk∗ −1 und Vzk∗ wird e;
(
i∗ + 1 falls Fusion erforderlich
beachte k ∗ :=
k + 1 sonst
(d) Entferne alle Kanten aus Heaps 6= e inzident zu v
(e) Neuer aktiver Pfad ist nun (z1 , . . . , zk∗ )
(f) Füge alle neuen Schnittkanten, die zu v inzident sind, in die entsprechenden Heaps
ein.
Hierarchietraversierung nun wie folgt:
Für jeden Knoten zk mit dzk ≥ 1 führe Extension aus, so lange es geht (d.h. bis Größenbedingung
erfüllt ist).
Algorithmus Chazelle(G, t)
Eingabe: ungerichteter gewichteter Graph G, Parameter t
Ausgabe: Minimaler Spannwald MSF(G)
1
2
3
4
5
6
7
8
if t = 1 oder kV k ≤ N0
then Bestimme MSF(G) mittels Boruvka-Algorithmus in O(n2 )-Version
fi
Führe c Boruvka-Phasen aus; X Menge der kontrahierten Kanten
Berechne Minorenhierarchie H mittels Retraktion und Extension
Bestimme
S Graph B der kritischen Kanten
F := z∈H MSF(G[Vz ] \ B, t − 1)
return MSF(F ∪ B, t) ∪ X
Algorithmus 11: Chazelle
Zur Korrektheit des Algorithmus:
Es sei G = (V, E, w) zusammenhängender gewichteter Graph. Eine Knotenmenge U ⊆ V heißt
streng kontrahierbar gdw. für alle Kanten e, f ∈ E(G) mit ke ∩ U k = kf ∩ U k = 1 ein Pfad
(h0 , h1 , . . . , hℓ ) mit h0 = e, hℓ = f und hi ∈ E(G[U ]) für 1 ≤ i ≤ ℓ − 1 existiert, für den
w(hi ) ≤ min{w(h0 = e), w(hℓ = f )} für alle 1 ≤ i ≤ ℓ − 1 gilt.
Proposition 9: Es sei G = (V, E, w) zusammenhängender gewichteter Graph. Ist U ⊆ V streng
kontrahierbar, so ist U kontrahierbar.
1.4. MINIMALE SPANNBÄUME
37
Beweis: Angenommen U wäre nicht kontrahierbar. D.h. G[U ] ∩ MST(G) hat mehr als eine
Zusammenhangskomponente. Sei p = (e1 , . . . , eℓ ) kürzester Pfad in MST(G) zwischen zwei Zusammenhangskomponenten U1 und U2 , seien u1 und u2 die zugehörigen Knoten. Es gilt ℓ ≥ 2
und ei 6∈ E(G[U ]) für alle 1 ≤ i ≤ ℓ, da p kürzester Pfad ist. Betrachten Pfad q in G[U ], der
u1 und u2 verbindet. Damit ist (p, q) Kreis in G. Nach Lemma 5 (rote regel) auf Seite 21 liegt
schwerste Kante g nicht in MST(G). D.h. g ∈ E(G[U ]). Widerspruch zu U streng kontrahierbar.
Lemma 10: Zum Zeitpunkt der Kontraktion ist jede Knotenmenge Vz streng kontrahierbar
bezüglich wwork .
Beweis: Verwende Invariante 1 auf Seite 35.
Für gewichteten Graphen G sei G0 der zugehörige Graph nach Ausführung der Boruvka-Phasen.
Lemma 11: Ist eine Kante e ∈ E(G) nicht kritisch und liegt e nicht in F , dann gehört e nicht
zu MSF(G0 ).
Beweis: Sei G∗0 der Graph, der aus G0 hervorgeht, indem alle in Schritt (5) entfernten Kanten
eliminiert werden. Wir unterscheiden zwei Fälle:
1. Es gilt e ∈ E(G∗0 ).
Dann gibt es maximalen“ Minor Xi , der e enthält (in Xi+1 wäre e kontrahiert). D.h. es
”
gibt z mit e ∈ Vz . Da e nicht kritisch und nicht in F , folgt e nicht in MSF(G∗0 ). Damit e
nicht in MSF(G0 ).
2. Es gilt e 6∈ E(G∗0 ).
Verwende Lemma 10 auf dieser Seite. Es folgt (mit einigen Argumenten) e 6∈ MSF(G0 )
Zeigen mittels Induktion, dass Algorithmus von Chazelle für Graphen G den MSF(G) berechnet:
Induktionsanfang: t = 1 oder n ≤ N0 : Klar wegen zeilen 1–3.
Induktionsschritt: t > 1, n > N0 :
Wir können annehmen, dass G zusammenhängend ist. In Zeile (4) werden nur MST-Kanten
kontrahiert. Nach Induktionsvoraussetzung bestimmen Zeile (7) (für t − 1) und in Zeile (8)
der Aufruf MSF(F ∪ B, t) (für n′ < n) korrekte MSF. Nach Lemma 11 folgt deshalb
Korrektheit von Zeile 8.
Überlegungen zur Komplexität des Algorithmus von Chazelle:
Lemma 12: Für Graph G sei G0 der Graph nach den Boruvka-Phasen im Algorithmus von
Chazelle, m0 sei die Anzahl der Kanten von G0 . Zum Aufbau der Hierarchie H werden maximal
4m0 Kanteneinfügungen in Soft Heaps vorgenommen.
Beweis: Führen amortisierte Analys mittels Bankkontomethode durch. Kanten werden zum
ersten Mal bei Extension eingefügt. Wählen:
• Gehalt G = 4e(bei Ersteinfügung)
• Sparstrategie:
38
KAPITEL 1. GRAPHENALGORITHMEN
– Jede Kante in H(j) spart 2e.
– Für alle i, j und Knoten v außerhalb Vz1 ∪· · ·∪Vzk haben die ℓ zu v inzudenten Kanten
Gesamtsparvolumen von ℓ + 2e falls ℓ > 0, sonst 0e.
Klar: mit 4e kann Sparstrategie bei erster Einfügung eingehalten werden; Kante kommt in Heap
H(i, k).
Betrachte Retraktion: Sei e = {u, v} Kkante aus H(k − 1, k) ∪ H(k), die wieder eingefügt werden
soll.
1. e ∈ H(k − 1, k), d.h. v inzident zu Kante ẽ ∈ H(i, k − 1), nach Invariante 2 auf Seite 35;
damit: Füge e ub H(k−1): Nach Sparstrategie ≥ 3e für e, k−1, k; bezahle 1e für Einfügen,
behalte 2e für Sparstrategie.
2. e ∈ H(k) und v inzident zu Kante ẽ ∈ H(k − 1, k), so füge e in H(k − 1) ein. Nach
Sparstrategie ≥ 2e+3e; bezahle 1e für Einfügen, behalte ≥ 2e für Sparstrategie.
3. e ∈ H(k), füge e in H(i, k − 1) ein. Nach Sparstrategie ≥ 2e für e; bezahle 1e für Einfügen,
behalte 1e für Sparstrategie.
Fusion wird analog behandelt.
Wie viele kritische Kanten gibt es? Mpssen kritische Kanten in Heaps H(·) und H(·, ·) zählen.
Für Knoten z und z ′ in H mit z ′ ∈ Hz (Knoten in H unterhalb von z):
• C(z, z ′ ) =def Menge der kritischen Kanten im Heap H(i, j) mit zi = z und zj = z ′ auf
aktivem Pfad (z1 , . . . , zi , . . . , zj , . . . , zk ) zum Zeitpunkt des Verschwindens
von H(i, j) (durch Merge oder Verwerfen).
• µ(z, z ′ ) =def maximake Anzahl von Kanten mit inzidentem Knoten v außerhalb Vz1 ∪ · · · ∪
Vzk in H(i, j) (mit i und j wie oben)
Wollen µ beschränken:
• Merge von H(i, j) und H(i, j ′ ) mit j ′ > j: µ(z, z ′ ) bleibt unverändert (nach Invariante 2
auf Seite 35)
• Insert in H(i, j) bei Extension: µ(z, z ′ ) := 1
• Insert in H(i, j) bei Retraktion: µ(z, z ′ ) höchstens inkrementiert (mit sofortiger Verschmelzung nach H(i, j − 1) (?))
→
µ(z, z ′ ) ≤ h(H) ≤ d.
1.4. MINIMALE SPANNBÄUME
39
Damit: sei C =def Menge aller kritischen Kanten.
H(·, ·)


[
[
′′ 
C(z, z ′ ) \
|Ck ≤4ε · m0 + C(z,
z
)
z,z′ ∈H
z ′′ ∈Hz ′
′
z ∈Hz
[
X ′′ C(z, z ′ ) \
C(z,
z
)
=4ε · m0 +
z ′′ ∈Hz ′
z,z ′ ∈H H(·)
z ′ ∈Hz
=4ε · m0 +
≤4ε · m0 +

X 
kC(z, z ′)k −

z,z ′ ∈H
z ′ ∈Hz
X
′
X
′′
z ∈Hz ′
z,z ∈H
z ′ ∈Hz z ′′ Kind von z ′
≤4ε · m0 +d ·
X
z ′′ ∈Hz ′
z ′′ Kind von z ′
µ( z, z ′′) +
| {z }
≤d
d+1
· n 0 + 4 · ε · m0
2
kC(z, z ′′ )k +
′
X
′
z ,z ∈H
z ′ Kind von z
z ′′

Anzahl kritischer KanX
ten, die aus H(i, j ′ )

gelöscht
werden
′′
z ∈Hz ′
während Extension
Kind von z ′
kC(z, z ′)k
≤8ε · m0 +d3 · n0 = O(m0 + d3 · n0 )
Damit: Schritte 4 und 5 benötigen O(m0 + d3 · n0 ) Schritte.
Gesamtkomplexität von MSF ergibt sich mittels ähnlicher Analyse wie eingangs zu O(t·(m+d3 n))
40
KAPITEL 1. GRAPHENALGORITHMEN
Kapitel 2
Algorithmen für Flüsse und
Matchings
2.1
Flüsse und Schnitte
Betrachten folgendes Szenario:
1/1
1
1/1
1/2
s
4
1/1
2
2/2
5
0/1
1/2
3/3
3
2/2
1/3
1/2
3/3
t
1/1
6
Frage: Sind 5 Pakete maximale Anzahl Pakete, die von s nach t gesendet werden können?
Ein Flussnetzwerk N = (V, E, e, s, t) ist ein gerichteter Graph G = (V, E) mit nicht-negativen
Kantengewichten, d.h. c : E → N, der zwei Knoten s, t ∈ V enthält, so dass s keine eingehenden
und t keine ausgehenden Kanten besitzt.
Der Knoten s ∈ V heißt Quelle von N , der Knoten t ∈ V heißt Senke von N . Für eine Kante
e ∈ E heißt c(e) die Kapazität von e.
1
1
1
s
2
4
1
2
3
5
1
3
2
3
2
2
2
3
t
1
6
Es sei N = (V, E, c, s, t) ein Flussnetzwerk. Ein (zulässiger) Fluss f für N ist eine Abbildung
f : E → N, die folgende Bedingungen erfüllt:
41
42
KAPITEL 2. ALGORITHMEN FÜR FLÜSSE UND MATCHINGS
1. Für alle e ∈ E gilt:
0 ≤ f (e) ≤ c(e)
(Kapazitätsregel)
2. Für alle Knoten v ∈ V \ {s, t} gilt:
X
f (e) =
X
f (e)
e∈E + (v)
e∈E − (v)
(Erhaltungsregel), wobei
E − (v) =def {(u, v) ∈ E | u ∈ V }
E + (v) =def {(v, u) ∈ E | u ∈ V }
Für Kante e ∈ E heißt f (e) Fluss über e. Der Betrag eines Flusses f , bezeichnet mit |f |, ist
definiert als
X
f (e)
|f | =def
e∈E + (s)
Der maximale Fluss f ∗ für N ist Fluss mit maximalem Betrag:
1
1/1
s
2/2
1/1
4
1/1
2
3
5
1/1
1/2
3/3
1/2
2/2
1/3
2/2
3/3
t
1/1
6
Ziel: Berechne maximale Flüsse möglichst effizient.
Alternativer Zugang zu Nerzwerkflüssen:
Es sei N = (V, E, c, s, t) ein Flussnetzwerk. Ein Schnitt in N ist eine Partition ξ = (Vs , Vt ) mit
s ∈ Vs , t ∈ Vt , Vs ∩ Vt = ∅ und Vs ∪ Vt = V . Eine Kante e ∈ E, e = (u, v) heißt bezüglich ξ
1. Vorwärtskante gdw. u ∈ Vs und v ∈ Vt
2. Rückwärtskante gdw. u ∈ Vt und v ∈ Vs
Es sei f : E → N ein Fluss in N . Der Fluss über den Schnitt ξ = (Vs , Vt ), bezeichnet f (ξ),
ist definiert als
X
X
f (ξ) =def
f (e) −
f (e)
e Vorwärtskante
e Rückwärtskante
2.2. MAXIMALER FLUSS
1
1/1
s
2/2
43
1/1
4
1/1
2
3
5
1/1
1/2
3/3
1/2
2/2
1/3
2/2
3/3
t
1/1
6
Vs = {s, 1, 2, 6}
Vt = {t, 3, 4, 5}
Fluss über ξ = (Vs , Vt ):
f (ξ) = 8 − 2 = 6
Lemma 13:
Es sei N ein Flussnetzwerk und es sei f ein Fluss. Für jeden Schnitt ξ von N gilt |f | = f (ξ).
Beweis: Betrachte für ξ = (Vs , Vt ) den Wert

X
X

F =def
v∈Vs
e∈E + (v)
f (e) −
X
e∈E − (v)
Nach Erhaltungsregel (für alle Knoten in Vs \ {s}) gilt
X
f (e) = |f |
F =

f (e)
e∈E + (s)
Andererseits: Ist e weder Vorwärts- noch Rückwärtskante für ξ, so enthält F entweder f (e) und
−f (e) oder nichts. D.h. F = f (ξ).
Für ein Flussnetzwerk N und einen Schnitt ξ ist die Kapazität von ξ definiert als
X
c(ξ) =def
c(e)
e Vorwärtskante
Lemma 14:
Es sei N ein Flussnetzwerk und ξ ein Schnitt von N . Für jeden Fluss f gilt f (ξ) ≤ c(ξ).
Beweis: klar wegen Kapazitätsregel.
Satz 15:
Es sei N ein Flussnetzwerk. Für jeden Fluss f und jeden Schnitt ξ gilt |f | ≤ c(ξ).
2.2
Maximaler Fluss
Es sei N = (V, E, c, s, t) ein Flussnetzwerk. Es sei f : E → N ein Fluss in N . Für eine Kante
e = (u, v) ∈ E ist die Restkapazität von u nach v bezüglich f , bezeichnet mit ∆f (u, v), definiert
als
∆f (u, v) =def c(e) − f (e)
∆f (v, u) =def f (e)
wenn keine bidirektionalen Kanten im Netzwerk vorkommen.
44
KAPITEL 2. ALGORITHMEN FÜR FLÜSSE UND MATCHINGS
Es sei p ein Pfad in N von s nach t, wobei Kanten in beiden Richtungen traversiert werden
können. Die Restkapazität von e in p ist definiert als
(
c(e) − f (e) falls e Vorwärtskante in p
∆f (e) =def
f (e)
falls e Rückwärtskante in p
Die Restkapazität eines Pfades p ist definiert als
∆f (p) =def min ∆f (e)
e∈p
Ein augmentierender Pfad p für den Fluss f ist ein Pfad von s nach t mit ∆f (p) > 0, d.h.
1. f (e) < c(e) für Vorwärtskante e
2. f (e) > 0 für Rückwärtskante e
1
0/1
1/2
s
(1)
0/1
4
(1)
1/1
0/2
(1)
(1)
2
0/1
0/2
2/3
3
|f | = 3
1
2/2
5
2/3 (2)
1/2
2/3
1/1
t
s
1/2
1/1
2
0/2
2/3
6
3
1/2
0/2
1/1
(1)
0/1
4
0/1
5
2/3
1/3
2/2
t
1/1
6
|f | = 4
∆f (p) = 1
Lemma 16:
Es sei N ein Flussnetzwerk und es sei f ein Fluss in N . Für jeden augmentierenden Pfad p in N
gibt es einen Fluss f ′ mit |f ′ | = |f | + ∆f (p).
Beweis: Wir definieren f ′ : E → N wie folgt:


falls e 6∈ p
f (e)
f ′ (e) = f (e) + ∆f (p) falls e Vorwärtskante in p


f (e) − ∆f (p) falls e Rückwärtskante in p
Es gilt:
1. f ′ (e) ≤ c(e) für alle Kanten e ∈ E
2. f ′ (e) ≥ f (e) ≥ 0 für alle Nicht-Rückwärtskanten e; für Rückwärtskante e gilt:
f ′ (e) = f (e) − ∆f (p) ≥ 0
| {z }
≤f (e)
3. Erhaltungsregel gilt klarerweise.
2.2. MAXIMALER FLUSS
45
Damit: f ′ zulässiger Fluss in N mit |f ′ | = |f | + ∆f (p).
Lemma 17:
Es sei N ein Flussnetzwerk. Gibt es für einen Fluss f in N keinen augmentierenden Pfad bezüglich
f , so ist f maimaler Fluss. Darüber hinaus gibt es einen Schnitt ξ mit |f | = c(ξ).
Beweis: Angenommen es gibt keinen augmentierenden Pfad in N . Wir konstruieren einen Schnitt
ξ wie folgt: Ein augmentierender Pfad von s nach v ∈ V ist ein Pfad mit echt positiven Restkapazitäten.
Definiere
Vs =def {v ∈ V | es gibt augmentierenden Pfad von s nach v} ∪ {s}
Vt =def V \ Vs
Es gilt: t 6∈ Vs , d.h. ξ = (Vs , Vt ) ist Schnitt. Es sei e eine Kante über ξ. Dann gilt ∆f (e) = 0, d.h.
(
c(e) falls e Vorwärtskante in ξ
f (e) =
0
falls e Rückwärtskante in ξ
Dann gilt |f | = f (ξ) = c(ξ). Nach Satz 15 auf Seite 43 ist |f | maximal.
Satz 18: (Max-Flow, Min-Cut Theorem)
Es sei N ein Flussnetzwerk. Dann gilt
max
f Fluss in N
|f | =
min
ξ Schnitt in N
c(ξ)
Beweis: Folgt direkt aus Satz 15 auf Seite 43 und Lemma 17.
Satz 18 gibt Idee zu Algorithmen: Suche solange nach augmentierenden Pfaden und aktualisiere
Flüsse, bis kein augmentierender Pfad mehr existiert.
46
KAPITEL 2. ALGORITHMEN FÜR FLÜSSE UND MATCHINGS
2.2.1
Algorithmus von Ford und Fulkerson
Algorithmus Ford-Fulkerson(N )
Eingabe: Flussnetzwerk N = (V, E, c, s, t)
Ausgabe: Maximaler Fluss f in N
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
Stop := FALSE
for e ∈ E
do f (e) := 0 od
while ¬Stop
Traversiere (V, E, c) von s aus, um augmentierenden Pfad p für f zu finden
if Pfad p existiert
then ∆ := +∞
for e ∈ p do
if ∆f (e) < ∆
then ∆ := ∆f (e)
fi
od
for e ∈ p do
if e Vorwärtskante in p
then f (e) := f (e) + ∆
else f (e) := f (e) + ∆
fi
od
else Stop := TRUE
fi
od
Algorithmus 12: Ford-Fulkerson
Beispiel: Abbildung 2.1 auf der nächsten Seite
Implementierungshinweise zu Zeile 5:
Zum Finden eines augmentierenden Pfades betrachte Restnetzwerk Rf = (V, Ẽ) zum Fluss f ,
definiert als
Ẽ =def {(u, v) | e = (u, v) ∈ E, f (e) < c(e)} ∪ {(v, u) | e = (u, v) ∈ E, f (e) > 0}
Beispiel: Abbildung 2.2 auf der nächsten Seite
Damit (für Zeile 5):
• bestimme Restnetzwerk Rf zum aktuellen Fluss f
• traversiere Rf mittels z.B. Tiefensuche oder Breitensuche ausgehend von s und bestimme
Pfad von snach t
⇒ benörigen zur Bestimmung eines augmentierenden Pfades O(m) Schritte
2.2. MAXIMALER FLUSS
0/1
1
0/1
s
0/2
0/1
0/1
0/1
2
1/1
0/3
0/2
0/3
3
1/1
0/1
1/1
2/2
1/1
2/3
0/2
2/3
3
3/3
2/2
s
t
0/1
0/3
0/2
0/1
∆f (p) = 2
1/1
4
1/1
2
2/2
1/2
3/3
5
1/1
1/3
1/2
3
1/1
6
2/2
|f ∗ | = 6
|f | = 6
Abbildung 2.1: Algorithmus von Ford-Fulkerson
s
1
4
2
5
3
6
t
Abbildung 2.2: Restnetzwerk Rf für |f | = 2
•
0/k
s
0/k
t
0/1
0/k
0/k
•
•
0/k
s
1/k
t
1/1
0/k
1/k
t
6
0/2
3/3
∆f (p) = 1
3/3
5
1/1
1/1
6
2/2
|f | = 5
5
0/2
2/2
2
|f | = 3
2/2
4
1/1
1
0/2
2
1/1
3
4
0/1
∆f (p) = 1
0/3
∆f (p) = 1
1/1
1
2/2
s
t
t
6
0/2
1/1
6
0/2
|f | = 2
2/3
5
0/3
0/2
1
1/2
1/3
5
1/1
|f | = 1
0/2
0/2
2
3
0/2
4
0/1
0/3
4
1/1
2/2
1/2
s
t
∆f (p) = 1
0/1
1
0/1
6
0/2
|f | = 0
0/2
0/3
5
0/3
0/2
0/1
1
0/2
2
3
s
4
0/1
0/3
s
47
•
1/k
s
t
0/1
1/k
1/k
•
Abbildung 2.3: Kritisches Beispiel für Ford-Fulkerson
1/k
•
t
48
KAPITEL 2. ALGORITHMEN FÜR FLÜSSE UND MATCHINGS
Komplexität von Ford-Fulkerson:
In jedem Durchlauf (Zeile 5 – 20) wird Betrag des aktuellen Flusses mindestens inkrementiert,
d.h. im schlechtesten Fall |f ∗ | Durchläufe.
⇒ Algorithmus von Ford-Fulkerson benötigt O(|f ∗ | · m) Schritte
In einem kritisches Beispiel für Ford-Fulkerson (Abbildung 2.3 auf der vorherigen Seite) werden
2k Iterationen ausgeführt, dabei sind zwei genug unabhängig von k!
2.2.2
Algorithmus von Edmonds und Karp
Verwende Breitensuche zur Bestimmung augmentierender Pfade (im Restnetzwerk) und führe
genauere Analyse durch.
Es sei N = (V, E, c, s, t) ein Flussnetzwerk und es sei f ein Fluss in N . Für einen Pfad p =
(e1 , . . . , eℓ ) mit ei ∈ E heißt ℓ die Länge von p.
Für einen Knoten v ∈ V ist die Restdistanz df (v) von v bezüglich f definiert als
df (v) =def
minimale Länge eines augmentierenden Pfades in N bezüglich f von s nach v,
oder +∞, falls kein solcher Pfad existiert.
Lemma 19:
Es sei N = (V, E, c, s, t) ein Flussnetzwerk. Es seien f, g Flüsse in N , wobei g aus f hervorgeht
durch Augmentierung eines Pfades p minimaler Länge. Dann gilt für alle v ∈ V
df (v) ≤ dg (v)
Beweis: (Widerspruch)
Angenommen es gibt Knoten, für die Restdistanzgleichung nicht gilt. Es sei v ∈ V Knoten mit
dg (v) minimal unter allen diesen Knoten. D.h. es gilt
1. df (v) > dg (v)
2. dg (v) ≤ dg (w) für alle w ∈ V mit df (w) > dg (w)
Es sei q ein augmentierender Pfad bezüglich g minimaler Länge von s nach v. Es sei w der
Vorgängerknoten von v in q; es sei e die Kante in q, die v mit w verbindet. Damit gilt:
q
3. ∆g (w, v) > 0
w
s
4. dg (v) = dg (w) + 1
p
t
p
v
5. df (w) ≤ dg (w) (wegen 1. und 2.)
Zeigen zunächst ∆f (w, v) = 0. Angenommen ∆f (w, v) > 0, d.h. es gibt augmentierenden Pfad
von w nach v bezüglich f . Damit
5.
4.
df (v) ≤ df (w) + 1 ≤ dg (w) + 1 = dg (v)
zu 1.
2.3. MAXIMALE MATCHINGS
49
D.h. obere Annahme oder ∆f (w, v) = 0. Betrachte Fall, dass ∆f (w, v) = 0.
Wegen ∆f (w, v) = 0 und ∆g (w, v) > 0 (3.) muss p die Kante e von v nach w traversieren. Damit
(5.)
(4.)
df (v) = df (w) − 1 ≤ dg (w) − 1 < dg (v) − 2 < dg (v)
zu 1.
Lemma 20:
Algorithmus von Edmonds und Karp benötigt zur Bestimmung eines maximalen Flusses in Netzwerk mit n Knoten und m Kanten höchstens n · m Augmentierungen.
Beweis: Es sei fi der aktuelle Fluss vor der i-ten Augmentierung bei Edmonds-Karp, pi sei der
zugehörige augmentierende Pfad. Kante e in pi heißt Engpass von pi , falls ∆fi (e) = ∆fi (pi ).
Beachte: Jeder augmentierende Pfad besitzt einen Engpass. Wir zeigen, dass jede Kante höchstens
n-mal Engpass sein kann.
Es seien u, v ∈ V Knoten mit inzidenter Kante e ∈ E. Seien pi und pk zwei augmentierende
Pfade kürzester Länge mit i < k, so dass e Engpass ist und von u nach v traversiert wird. Damit
gilt:
1. ∆fi (u, v) > 0
2. ∆fi+1 (u, v) = 0
3. ∆fk (u, v) > 0
D.h. es gibt pj mit i < j < k, so dass e von v nach u traversiert wird. Damit gilt:
pj kürzester
Pfad
dfj (u)
=
dfj (v) + 1
Lemma 19
≥
pi kürzester
Pfad
dfi (v) + 1
=
dfi (u) + 2
Da Restdistanz höchstens n ist, kann jede Kante höchstens n-mal Engpass sein ( n2 -mal für jede
Orientierung). D.h. höchstens n · m Augmentierungen.
Komplexität von Edmonds-Karp:
• O(n · m) Augmentierungen
• O(m) pro Augmentierung für Breitensuche
⇒ O(n · m2 ) Schritte
Bemerkung: Es gibt Algorithmen, die nicht auf Max-Flow, Min-Cut
z.B.
Theorem 2basieren,
Push-Relabel-Algorithmus von Goldberg und Tarjan mit Laufzeit O n · m · log nm
2.3
Maximale Matchings
Ziel: Anwendung von Flussalgorithmen auf Matching-Probleme in bipartiten Graphen.
50
KAPITEL 2. ALGORITHMEN FÜR FLÜSSE UND MATCHINGS
Es sei G = (V, E) ein ungerichteter Graph. G heißt bipartit gdw. es gibt X, Y ⊆ V mit X ∩ Y =
∅, X ∪ Y = V und für alle e ∈ E gilt ke ∩ Xk = ke ∩ Y k = 1, d.h. ein Endpunkt liegt in X und
einer in Y .
Ein Matching in G ist eine Kantenmenge M ⊆ E mit e ∩ f = ∅ für alle e, f ∈ M, e 6= f , d.h.
Kanten in M haben keine gemeinsamen Knoten.
Matching maximaler Kardinalität heißt maximales Matching, bezeichnet M ∗ .
Bsp.:: X =Menge der Vorlesungen; Y =Menge der Hörsäle; Kante e = {x, y} bedeutet, dass
Vorlesung x in Hörsaal y gehalten werden kann (weil z.B. Projektoren, Tafeln o.ä. vorhanden
sind). Maximales Matching gibt an, wie viele Vorlesungen gleichzeitig gehalten werden können.
Jetzt: Formulieren Matching-Problem als Fluss-Problem.
Es sei G = (V, E) ein bipartiter Graph. Definiere NG = (VG , EG , c, s, t) wie folgt:
• VG =def V ∪ {s, t}
(s, t 6∈ V )
• EG =def {(s, v) | v ∈ X} ∪ {(u, v) | u ∈ X, v ∈ Y, {u, v} ∈ E} ∪ {(v, t) | v ∈ Y }
• c ≡ 1, d.h. für alle e ∈ EG gilt c(e) = 1
•
•
•
•
•
•
•
•
•
•
•
•
•
s
•
•
•
•
•
t
•
•
Proposition 21:
Es sei G bipartiter Graph und NG das zugehörige Flussnetzwerk. Ist M ∗ maximales Matching
in G und f ∗ maximaler Fluss in NG , so gilt kM ∗ k = |f ∗ |.
Beweis: Zeigen, dass jedes Matching M einen Fluss fM definiert mit kM k = |fM |, und umgekehrt jeder Fluss f ein Matching Mf mit |f | = kMf k.
1. Es sei M ein Matching in G. Definiere fM : EG → N wie folgt für e ∈ EG :
fM (e) =def

1



1

1



0
fallse ∈ M
fallse = (s, v)und es gibt w mit{v, w} ∈ M
fallse = (v, t)und es gibt w mit{v, w} ∈ M
sonst
Klar: f erfüllt Kapazitätsregel und Erhaltungsregel. Außerdem: |fM | = kM k.
2. Es sei f Fluss in NG . Definiere Menge M ⊆ E wie folgt:
{u, v} ∈ M
⇔def
f (e) = 1, e = (u, v) ∈ EG , {u, v} ∩ {s, t} = ∅
2.4. FLÜSSE MIT MINIMALEN KOSTEN
51
Müssen zeigen, dass M Matching ist. Da c(e) ∈ {0, 1} für alle e ∈ EG , folgt f (e) ∈ {0, 1}
−
für alle e ∈ EG . Für alle x ∈ XM gilt |EG
(x)k = 1, damit gibt es nach Erhaltungsregel
+
genau ein y ∈ Y mit e = (x, y) ∈ EG und f (e) = 1. Analog gilt kEG
(y)k = 1 für alle
y ∈ YM , damit existiert genau ein x ∈ X mit e = (x, y) ∈ EG und f (e) = 1. D.h. für jedes
x ∈ X gibt es höchstens ein y ∈ Y mit {x, y} ∈ M und umgekehrt. D.h. M ist Matching.
Außerdem: |Mf k = |f |.
•
•
•
•
•
•
•
•
•
•
•
•
•
s
•
•
•
•
•
t
•
•
Komplexität von Ford-Fulkerson für maximales Matching:
• Berechnung von NG zu gegebenem G in O(n+ m); NG hat n+ 2 Knoten und n+ m Kanten.
• Es gilt |f ∗ | = kM ∗ k ≤ n2 . Damit Berechnung des maximalesn Flusses in NG in O(n(n +
m)) = O(n · m), wenn G zusammenhängend.
⇒ O(n · m) Schritte zur Berechnung eines maximalen Matchings.
2.4
Flüsse mit minimalen Kosten
Bisher: kein Unterschied, über welchen augmentierenden Pfad eine Flusseinheit geschickt wurde,
d.h. alle Kanten gleich teuer.
Jetzt: zusätzlich für jede Kante e auch Gewicht w(e) mit w : E → N.
Gegeben Flussnetzwerk N = (V, E, c, s, t) mit Gewichtsfunktion w und Fluss f in N , so sind die
Kosten e(f ) von f definiert als
w(f ) =def
X
e∈E
w(e) · f (e)
Ein Fluss f ist Fluss mit minimalen Kosten, falls w(f ) ≤ w(f ′ ) für alle Flüsse f ′ mit
|f | = |f ′ |.
Ziel: Bestimme Fluss mit minimalen Kosten unter allen maximalen Flüssen.
Es sei p = (e1 , . . . , ek ) augmentierender Pfad in N bezüglich Fluss f . Dann sind die Kosten w(p)
von p definiert als
X
X
w(p) =def
w(e) −
w(e)
e Vorwärtskante
in p
e Rückwärtskante
in p
52
KAPITEL 2. ALGORITHMEN FÜR FLÜSSE UND MATCHINGS
Ein augmentierender Kreis p in N bezüglich f ist ein augmentierender Pfad, dessen erster
und letzter Knoten identisch sind, d.h. p = (v0 , v1 , . . . , vk ) mit
• vi ∈ V für alle 0 ≤ i ≤ k
• v0 = vk und vi 6= vj für alle 0 ≤ i < j < k
• (vi , vi+1 ) ∈ E oder (vi+1 , vi ) ∈ E für alle 0 ≤ i < k
• ∆f (vi , vi+1 ) > 0 für alle 0 ≤ i < k
Restkapazität und Kosten übertragen sich sinngemäß auf augmentierende Kreise.
Beachte: Augmentierung entlang eines Kreises führt zu keiner Betragsänderung des Flusses,
wohl aber zu veränderten Kosten.
u
u
1/2,3
1/3,2
s
0/3,1
t
2/2,3
2/4,1
v
0/2,3
1/3,2
s
1/3,1
t
2/2,3
3/4,1
v
• |f | = 3
• |f | = 3
• w(f ) = 3 + 2 + 2 + 6 = 13
• w(f ) = 3 + 1 + 6 + 2 = 12
• p = (s, v, u, s)
• ∆f (p) = 1
• w(p) = −1
Lemma 21:
Es seien N ein Flussnetzwerk und f ein Fluss in N . Für jeden augmentierenden Kreis p in N
bezüglich f gibt es einen Fluss f ′ in N mit
1. |f ′ | = |f |
2. w(f ′ ) = w(f ) + w(p) · ∆f (p)
Beweis: analog zu Lemma 16 auf Seite 44.
Satz 22:
Es sei N ein Flussnetzwerk. Der Fluss f in N hat minimale Kosten unter allen Flüssen mit
Betrag |f | in N genau dann wenn es gibt keinen augmentierenden Kreis in N bezüglich f mit
negativen Kosten.
Beweis:
⇒“ Folgt aus Lemma 21 (Kontraposition)
”
2.4. FLÜSSE MIT MINIMALEN KOSTEN
53
⇐“ (Kontraposition) Es sei f Fluss in N , der nicht minimale Kosten besitzt. Sei g Fluss mit
”
minimalen Kosten und |g| = |f |. Dann gibt es eine endliche Folge von augmentierungen
entlang augmentierender Kreise, so dass g aus f entsteht. Da w(g) < w(f ) muss mindestens
ein Kreis negative Kosten besitzen (Lemma 21 auf der vorherigen Seite).
Seien f, g Flüsse in N , w(g) < w(f ). Betrachten Rg−f =def (V, Eg−f ) mit
Eg−f = {(u, v) | g(u, v) > f (u, v)} ∪ {(v, u) | g(u, v) > f (u, v)}
|
{z
} |
{z
}
ŵ(e) =
(
+
Eg−f
−
Eg−f
+
w(e), e ∈ Eg−f
−
−w(ē), e ∈ Eg−f
wobei ē die e entgegengesetzte Kante ist.
g′
f
u
1/2,3
u
1/3,2
s
0/3,1
t
2/2,3
2/4,1
Rg′ −f
u
0/2,3
2/3,2
s
2/3,1
t
1/2,3
3/4,1
v
v
w(f ) = 13
w(g ′ ) = 12
1,−3
1,2
s
t
2,1
1,1
1,3
v
Satz 22 liefert folgenden algorithmischen Ansatz:
1. bestimme maximalen Fluss f ∗ mit Hilfe von Ford-Fulkerson oder Edmonds-Karp
2. Bestimme negative Kreise in Rf ∗ (bezüglich Gewicht w) und augmentiere diese Kreise bis
kein negativer Kreis mehr existiert.
Komplexität des Algorithmus:
• O(|f ∗ | · m) für Ford-Fulkerson
• Es sei w∗ Kosten des initialisierten maximalen Flusses f ∗ .
⇒ O(w∗ · n · m) Schritte für maximal w∗ Augmentierungen mit je O(n · m) Schritten für
Bellmann-Ford.
alternativer Zugang: Verwende zur Augmentierung stets augmentierenden Pfad mit minimalen
Kosten.
Satz 23:
Es sei N ein Flussnetzwerk mit Gewichtsfunktion w. Es seien f und f ′ Flüsse in N , wobei
f minimale Kosten hat und f ′ aus f durch Augmentierung des Pfades mit minimalen Kosten
entsteht. Dann ist f ′ Fluss mit minimalen Kosten.
Beweis: Es sei f Fluss mit minimalen Kosten. Außerdem sei p augmentierender Pfad in N
bezüglich f mit minimalen Kosten. Es entstehe f ′ durch augmentierung entlang p aus f .
54
KAPITEL 2. ALGORITHMEN FÜR FLÜSSE UND MATCHINGS
Angenommen f ′ hat nicht minimale Kosten. Dann gibt es augmentierenden Kreis q in N bezüglich
f ′ mit negativen Kosten. Es gilt:
1. Es gibt Kante e in q, die auch zu p gehört.
Begründung: Angenommen e nicht in p, dann ist q augmentierender Kreis in N bezüglich
f mit negativen Kosten. D.h. f hat nicht minimale Kosten .
2. Es gibt Kante e in q und p, die in q in entgegengesetzter Richtung zu p traversiert wird.
Begründung: Angenommen alle Kanten in p und q werden in p in gleiche Richtung traversiert wie in q. Dann existiert Kreis q bereits bezüglich f . D.h. f hat nicht minimale
Kosten
q′
Es sei e (ohne Begründung die einzige) Kante, die 2. genügt. s
′
p
′
•
e
′
•
p
t
Es sei q =def q \ {e}. Betrachte Pfad p , der aus p durch Ersetzung von e mit q entsteht. Dann
ist p′ augmentierender Pfad in N bezüglich f . Außerdem:
<0
z }| {
w(p ) = w(p) + w(q) < w(p)
| {z } | {z }
′
mit e
mit ē
D.h. p nicht mit minimalen Kosten.
Der Beweis funktioniert nicht mehr, falls p mehr alls eine Kante mit q gemeinsam hat. Der
entsprechende Abschnitt bei Goodrich und Tamassia ist falsch.
Ein entsprechender Beweis wird auf der Homepage der Vorlesung verfügbar gemacht. Grundideen
dazu: Sei p Pfad oder Kreis.
X p : E → {−1, 0, 1}


falls e Vorwärtskante in p
1
p
X = −1 falls e Rückwärtskante in p


0
sonst
P
P
Es gilt: f − g =
λi X pi + µj X cj , wobei λi , µi > 0, pi , cj augmentierende Pfade bzw. Kreise
in Rg . Konkret zum Beweis von Satz 23 auf der vorherigen Seite: Sei f ′′ Fluss mit |f ′′ | = |f ′ |.
X
X
µj X cj
X
X
X
X
w(f ′′ − f ) =
λi w(pi ) +
µj w(cj ) ≥
λj w(pj ) ≥ w(p)
λj = w(p)∆p (p)
f ′′ − f =
λi X pi +
w(f ′′ − f ) ≥ w(f ′ − f ) ⇔ w(f ′′ ) ≥ w(f ′ )
Satz 23 auf der vorherigen Seite impliziert folgendes algorithmisches Verfahren:
1. Initialisiere Nullfluss f ≡ 0 (f hat minimale Kosten)
2.4. FLÜSSE MIT MINIMALEN KOSTEN
55
2. Es sei f aktueller Fluss. Betrachte Restnetzwerk Rf = (V, Ef ) mit folgenden Gewichten
w(u, v) =
(
w(e)
−w(e)
, falls e = (u, v) ∈ Ef
, falls e = (v, u) ∈ Ef
Bestimmen Pfad p mit minimalem Gewicht in Rf (z.B. mit Bellmann-Ford); beachte:. Rf
enthält keine negativen Kreise
3. Falls p existiert, bestimme neuen aktuellen Fluss f durch Augmentierung von p und fahre
mit 2. fort; sonst: gebe f zurück
f
u
u
0/2,3
0/3,2
s
t
0/3,1
0/2,3
0/4,1
3/3,1
2,3
v
s
1,1
1/2,3
4/4,1
3/3,2
s
2/3,1
t
2/2,3
4/4,1
v
3,−2
3,−1
t
3/3,1
1/2,3
v
u
2,3
t
3/3,2
s
u
3,1
u
0/2,3
v
3,2
4,1
t
0/2,3
3/4,1
u
2,3
s
3/3,2
s
v
Rf
u
0/2,3
t
3,−1
2,3
v
2,3
s
3,−2
t
1,−3
3,−1
4,−1
v
1,3
Komplexität des Algorithmus:
• max. |f ∗ | Iterationen
• O(n · m) pro Iteration für Bellman-Ford
⇒ O(|f ∗ | · n · m) Schritte
Jetzt: Ersetzung von Bellman-Ford durch Dijkstra mittels Gewichtskalibrierung.
Es sei N = (V, E, c, s, t) ein Flussnetzwerk mit Gewichtsfunktion w. Es sei f ein Fluss mit
minimalen Kosten.
Es sei df (v) für Knoten v ∈ V der Abstand von v zur Quelle s in Rf , d.h.
df (v) =def min{w(p) | p Pfad in Rf von s nach v}
(Beachte: df (v) verschieden zu Abstand bei Edmonds-Karp)
Es sei g Fluss in N , der aus f durch Augmentierung eines Pfades mit minimalen Kosten entsteht.
Wir definieren für Rg modifizierte Gewichte ŵ wie folget: (u, v) ∈ Eg
ŵ(u, v) =def w(u, v) + df (u) − df (v)
56
KAPITEL 2. ALGORITHMEN FÜR FLÜSSE UND MATCHINGS
Beobachtung: Sei p ein beliebiger Pfad von s nach v ∈ V bezüglich g. Dann gilt für p =
(u0 , u1 , . . . , uk ), u0 = s, uk = v:
ŵ(p) =
k
X
ŵ(ui−1 , ui )
i=1
=
k
X
i=1
[w(ui−1 , ui ) + df (ui−1 ) − df (ui )]
=w(p) + df (s) − df (v)
=w(p) − df (v)
Lemma 24:
Für jede Kante (u, v) ∈ Eg gilt ŵ(u, v) ≥ 0. Weiterhin ist kürzester Pfad in Rg bezüglich ŵ
ebenfalls kürzester Pfad in Rg bezüglich w.
Beweis: Wir unterscheiden zwei Fälle für (u, v) ∈ Eg .
1. Es gilt (u, v) ∈ Rf . Dann gilt df (v) ≤ df (u) + w(u, v)
Damit:
ŵ(u, v) = w(u, v) + df (u) − df (v) ≥ 0
2. Es gilt (u, v) 6∈ Rf . Dann ist (v, u) Kante auf augmentierendem Pfad p, der g aus f
produziert. D.h.
df (u) = df (v) + w(v, u)
| {z }
=−w(u,v)
Damit:
ŵ(u, v) = w(u, v) − w(u, v) = 0
Weiterhin: Nach Beobachtung ist kürzester Pfad von s nach t in Rg bezüglich ŵ auch kürzester
Pfad bezüglich w.
2.4. FLÜSSE MIT MINIMALEN KOSTEN
Algorithmus MinCostFlow(N )
Eingabe: Flussnetzwerk N = (V, E, c, s, t) mit Gewichtsfunktion w : E → N
Ausgabe Maximaler Fluss f mit minimalen Kosten
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
for e ∈ E
do f (e) := 0 od
for v ∈ V
do d(v) := 0 od
Stop := FALSE
while ¬Stop do
Bestimme Restnetzwerk Rf = (V, Ef )
for (u, v) ∈ Ef
do ŵ(u, v) := w(u, v) + d(u) − d(v) od
Bestimme kürzeste Pfade p(v) in Rf
bezüglich ŵ von s zu allen Knoten v ∈ V mit
Hilfe von Dijkstra
for v ∈ V
do d(v) := w(p(v)) od
if d(t) < ∞
then ∆ := ∞
for e ∈ p(t) do
if df (e) < ∆
then ∆ := df (e)
fi
od
for e ∈ p(t) do
if e Vorwärtskante in p(t)
then f (e) := f (e) + ∆
else f (e) := f (e) − ∆
fi
od
else Stop := TRUE
fi
od
Algorithmus 13: MinCostFlow
57
58
KAPITEL 2. ALGORITHMEN FÜR FLÜSSE UND MATCHINGS
f
u
u
0/2,3
0/3,2
s
0/3,1
0/4,1
t
0/2,3
u
0/2,3
3/3,2
s
3/3,1
3/4,1
v
t
0/2,3
0/2,3
u
3/3,2
s
t
3/3,1
4/4,1
1/2,3
v
1/2,3
3/3,2
s
2/3,1
4/4,1
v
t
2/2,3
v
Rf , w
u
u
2,3
s
t
3,1
2,3
4,1
u
2,3
3,2
s
3,−1
t
3,−1
2,3
1,1
v
2,3
3,−2
s
u
3,−2
4,−1
v
t
1,−3
3,−1
s
1,3
v
t
v
Rf , ŵ, d(v)
0
2
2,3
3,2
0
0
3,1
4,1
2,3
2
2,1
0
3,0
2,0
1,0
0
4
3,0
3,0
2,1
0
3
3,0
3,0
1,0
4,0
1
4
0
5
1,0
1
2
Komplexität von MinCostFlow:
• Zeilen 1–5: O(n + m)
• Zeilen 6–23
– max. |f ∗ | Iterationen
– Zeilen 7–9: O(n + m)
– Zeile 10: O(n log n + m) (bei Verwendung von Fibonacci-Heaps für Dijkstra)
– Zeilen 11–22: O(n)
⇒ O(|f ∗ | · (n log n + m)) Schritte für MinCostFlow
Kapitel 3
Lineare Programmierung
Ein Beispielproblem:
Angenommen wir wollen ein neues Produkt vermarkten. Dabei bestehe folgender Zusammenhang
zwischen Werbungskosten für bestimmte Medien und dabei erzielbaren Neukunden:
Medien
pro e 1.000
Kino
Fernsehen
Radio
Zeitung
Zielgruppe
14–29 39–49 50–
7
3
0
10
2
5
2
4
5
1
8
6
Ziel: mindestens 500.000 neue Kunden im Alter von 14–29
mindestens 200.000 neue Kunden im Alter von 30–49
mindestens 50.000 neue Kunden im Alter von 50–
D.h. es muss gelten:
7x1 +10x2 +2x3 +1x4 ≥ 500
3x1 + 2x2 +4x3 +8x4 ≥ 500
0x1 + 5x2 +5x3 +6x4 ≥ 500
x1 , x2 , x3 , x4 ≥ 0
Gesamtaufgabe: 1x1 + 1x2 +1x3 +1x4
3.1
soll minimiert werden
Standardformulierungen
Ein Tripel (A, b, c) heißt lineares Programm (LP), falls A eine m × n-Matrix, b ein mdimensionaler Vektor und c ein n-dimensionaler Vektor sind. Matrizen und Vektoren werden
über Q aufgefasst. Dimension von LP (A, b, c) ist m × n.
59
60
KAPITEL 3. LINEARE PROGRAMMIERUNG
Die durch das LP (A, b, c) gegebene Optimierungsaufgabe ist wie folgt definiert:
Maximiere
bezüglich
n
X
i=1
n
X
j=1
ci xi
aij xj ≤ bi für alle i ∈ {1, . . . , m}
xj ≥ 0 für alle j ∈ {1, . . . , n}
oder kurz:
Maximiere cT x
bezüglich Ax ≤ b
x≥0
Bezeichnungen:
• cT x heißt Zielfunktion
• Ax ≤ b heißen Nebenbedingungen
• x ≥ 0 heißen Nichtnegativitätsbedingungen
Es sei (A, b, c) ein LP. Ein Vektor x ∈ Rn heißt zulässige Lösung, falls Ax ≤ b und x ≥ 0; sonst
unzulässige Lösung. Für zulässige Lösung x heißt cT x Zielwert. Eine zulässige Lösung x∗
mit maximalem Zielwert unter allen zulässigen Lösungen heißt optimale Lösung; cT x∗ heißt
optimaler Zielwert.
Ein LP ohne zulässige Lösung heißt unerfüllbar; sonst erfüllbar. Ein erfüllbares LP ohne
endlichen optimalen Zielwert heißt unbeschränkt.
LP-Variationen:
1. Minimierung der Zielfunktion statt Maximierung
2. Existenz von Variablen ohne Nichtnegativität
3. Gleichheiten unter Nebenbedingungen
4. entgegengesetzte Ungleichungen
Es seien L1 ein m1 × n1 -dimensionales LP und L2 ein m2 × n2 -dimensionales LP.
L1 ist einfacher als L2 , symbolisch L1 ≤ L2 , falls eine Funktion ϕ : Rn1 → Rn2 existiert, so
dass für alle x ∈ Rn1 gilt:
(i) Ist x zulässige Lösung für L1 , so ist ϕ(x) zulässige Lösung für L2
(ii) Für zulässige Lösung x von L1 gilt cT1 x = cT2 ϕ(x). Ist genau ein Problem von L1 und L2
ein Minimierungsproblem, so gilt cT1 x = −cT2 ϕ(x).
3.1. STANDARDFORMULIERUNGEN
61
L1 und L2 sind äquivalent, falls L1 ≤ L2 und L2 ≤ L1 .
Jetzt: Elimination der Varianten
1. LP L1 mit Minimierung von cT x wird zu LP L2 mit Maximierung von (−c)T x
Klar: L1 ≡ L2
Minimiere −2x1 +3x2
bezüglich
x1 +x2 =7
Maximiere 2x1 −3x2
bezüglich x1 +x2 =7
x1 −2x2 ≤4
x1
≥0
x1 −2x2 ≤4
x1
≥0
2. LP L1 mit Variable xi ohne Nichtnegativität wird zu LP L2 , bei dem xi durch x′i − x′′i mit
Bedingung x′i , x′′i ≥ 0 ersetzt wird.
Klar: L1 ≡ L2
P
P
P
3. Lp L1 mit
aij xj = bi wird zu LP L2 mit
aij xj ≤ bi und
aij xj ≥ bi .
Klar: L1 ≡ L2
P
P
4. LP L1 mit
aij xj ≥ bi wird zu LP L2 mit (−aij )xj ≤ −bi
Klar: L1 ≡ L2
Beispiel in Standardform


 
 
−1 −1 1
−7
2
A= 1
1 −1 , b =  7  , c = −3
1 −2 2
4
3
Jetzt: Wichtige Normalform (für Simplex-Algorithmus).
Pn
Es sei (A, b, c) ein LP. Für Nebenbedingung j=1 aij xj ≤ bi führe Schlupfvariable si ein mit:
si = b i −
si ≥ 0
n
X
aij xj
j=1
Beispiel:
Max.
2x1 −3x2 +3x3
x4 =−7+ x1 + x2 − x3
x5 = 7− x1 − x2 + x3
x6 = 4− x1 +2x2 −2x3
x4 , x5 , x6 heißen Basisvariablen; x1 , x2 , x3 heißen Nichtbasisvariablen
62
KAPITEL 3. LINEARE PROGRAMMIERUNG
In Simplexalgorithmus werden Basisvariablen durch Nichtbasisvariablen ausgetauscht. Dadurch
ändert sich im Allgemeinen die Zielfunktion.
LP in Simplex-Normalform wird dann geschrieben als:
z = 0+2x1 −3x2 +3x3
x4 =−7+ x1 + x2 − x3
x5 = 7− x1 − x2 + x3
x6 = 4− x1 +2x2 −2x3
Ein Tupel (N, B, A, b, c, v) heißt LP in Simplex-Normalform, falls (A, b, c) ein m×n-dimensionales
LP ist und N ∪ B = {1, 2, . . . , n + m}, N ∩ B = ∅, und gilt:
X
z=v+
cj xj
j∈N
xi = bi −
X
j∈N
aij xj für i ∈ B
Beachte: Elemente in A, b, c müssen so nummeriert sein, dass die beiden obigen Gleichungen
wohldefiniert sind.
z = 8+ x2 +7x3 −x6
x1 = 4+2x2 +2x3 −x6
x4 =−3+3x2 + x3 −x6
x5 = 3−3x2 − x3 +x6
B = {1, 4, 5}
N = {2, 3, 6}
 


2
2 −1
a12 a13 a16
1 −1
a = a42 a43 a46  =  3
a52 a53 a56
−3 −1 1
b = (b1 , b4 , b5 )T = (4, −3, 3)T
c = (c2 , c3 , c6 )T = (1, 7, −1)T
v=8
Lemma 25:
Es sei I ⊆ N eine nicht leere Indexmenge. Für i ∈ I seien αi , βi reelle Zahlen und xi reell-wertige
Variablen. Es sei γ ∈ R. Gilt für alle xi ∈ R für alle i ∈ I,
X
X
αi xi = γ +
βi xi
i∈I
so gilt αi = βi für alle i ∈ I und γ = 0.
i∈I
3.1. STANDARDFORMULIERUNGEN
63
Beweis: Setze xi = 0 für alle i ∈ I. Dann gilt γ = 0. Betrachte nun für jedes i ∈ I die Belegung
(
0 , falls j ∈ I \ {i}
xj =
1 , falls j = i
Dann gilt αi = 0 + βi = βi .
Satz 26: Es sei (A, b, c) ein LP. Gegeben eine Menge B von Basisvariablen, so ist die zugehörige
Simplex-Normalform eindeutig bestimmt.
Beweis: Angenommen es gibt zwei Simplex-Normalformen mit gleicher Menge B. Dann haben
beide auch gleiche Menge an Nichtbasisvariablen N = {1, . . . , n + m} \ B. Für erste NF gilt:
X
(i)
z=v+
cj xj
j∈N
xi = bi −
(ii)
X
aij xj für i ∈ B
X
c′j xj
j∈N
und für zweite NF gilt:
z = v′ +
(iii)
j∈N
(iv)
xi =
b′i
−
X
j∈N
Betrachte (ii)−(iv) für jedes i ∈ B:
0 = (bi − b′i ) −
d.h.
X
j∈N
a′ij xj für i ∈ B
X
j∈N
(aij − a′ij )xj
a′ij xj = (bi − b′i ) +
X
aij xj
X
cj xj
j∈N
Nach Lemma 25 gilt aij = a′ij und bi = b′i . Analog (i)−(iii)
X
0 = (v − v ′ ) +
(cj − c′j )xj
j∈N
d.h.
X
j∈N
c′j xj = (bi − b′i ) +
Damit: nach Lemma 25 gilt c′j = cj und v = v ′ .
3.1.1
j∈N
Beispiele für LP-Modellierungen
Kürzeste Wege: Es sei G = (V, E) gerichteter Graph mit Gewichtsfunktion w : E → R. Es
seien s, t ∈ V . Suche kürzesten Weg von s nach t.
LPG : Maximiere
bezüglich
dt
dv ≤ du + w(u, v) für (u, v) ∈ E
ds = 0.
zu Zeigen: dG (s, t) = optimaler Zielwert von LPG .
64
KAPITEL 3. LINEARE PROGRAMMIERUNG
≤ Setze dv = dG (s, v) für alle v ∈ V . Dann gilt für (u, v) ∈ E: dv ≤ du + w(u, v).
Außerdem ds = 0. D.h. Zuordnung definiert zulässige Lösung. D.h. dG (s, t) = dt ≤ d∗t
≥ Es sei d∗v optimale Lösung für LPG . Es sei (vo , v1 , . . . , vℓ ) mit s = v0 , t = vℓ kürzester
Weg in G. Dann gilt für alle 1 ≤ i ≤ ℓ:
(∗)
dG (s, vi ) = dG (s, vi−1 ) + w(vi−1 , vi )
Zeigen d∗vi ≤ dG (s, vi ) mittels Induktion über i:
(IA): Es sei i = 0. Dann d∗v0 = d∗s = 0 = dG (s, s)
(IS): Es sei i > 0. Dann gilt
(IV)
(∗)
d∗vi ≤ d∗vi−1 + w(vi−1 , vi ) ≤ dG (s, vi−1 ) + w(vi−1 , vi ) ≤ dG (s, vi )
Größe von LPG für G = (V, E):
• kV k Variablen
• kEk + 1 Nebenbedingungen
Maximaler Fluss: Es sei N = (V, E, c, s, t) Flussnetzwerk. Suche maximalen Fluss in N . (Verwende Vereinbarung c(u, v) = 0 für (u, v) 6∈ E)
X
LPN : Maximiere
f(s,v)
v∈V
bezüglich
f(u,v) ≤ c(u, v) für u, v ∈ V
fX
(u,v) = −f(v,u) für u, v ∈ V
f(u,v) = 0 für u ∈ V \ {s, t}
v∈V
Größe von LPN :
• 2kV k2 Variablen
• kV k2 + 2kV k2 + 2(kV k − 2) = 2(kV k2 + kV k + 2) Nebenbedingungen
3.2
3.2.1
Simplex-Algorithmus
Grundlagen
Betrachten einfaches LP:
Maximiere
bezüglich
2x1 + x2
x1 + x2 ≤ 7
2x1 − x2 ≤ 4
−6x1 + x2 ≤ 0
3.2. SIMPLEX-ALGORITHMUS
65
6
@
@
@
@
Bereich zulässiger Lösungen
@
= Schnitt von Halbebenen
@ @
@
@
@
@
@
@
@
@
@
@
@
@
@ -
Optima werden immer in Ecken (des Simplex) angenommen.
Ziel: Finde richtinge Ecke.
Ecken sind dadurch charakterisiert, dass die zugehörigen Ungleichungen ausgeschöpft werden,
d.h. Schlupfvariable wird 0.
Betrachten Beispiel in Simplex-Normalform
z = 0+3x1 + x2 +2x3
x4 =30− x1 − x2 −3x3
x5 =24−2x1 −2x2 −5x3
x6 =36−4x1 − x2 −2x3
B = {4, 5, 6}, N = {1, 2, 3}
Setzen x1 = 0, x2 = 0, x3 = 0. Dann x4 = 30, x5 = 24, x6 = 36. Nennen (0, 0, 0, 30, 24, 36)
Basislösung. (Beachte: Diese Basislösung entspricht einer zulässigen Lösung.)
Idee des Simplex-Algorithmus: Setze sukzessive Basisvariablen auf 0 durch geeigneten Variablentausch (springe zur nächsten Ecke).
Wollen z erhöhen. Dazu können wir x1 , x2 , x3 erhöhen. Erhöhe x1 :
• in Gleichung für x4 : maximal auf 30
• in Gleichung für x5 : maximal auf 12
• in Gleichung für x6 : maximal auf 9
66
KAPITEL 3. LINEARE PROGRAMMIERUNG
1
1
1
Vertausche x6 mit x1 : x1 = 9 − x2 − x3 − x6 . Neues LP wie folgt:
4
2
4
1
3
1
z =27+ x2 + x3 − x6
4
2
4
1
1
1
x1 = 9− x2 − x3 − x6
4
2
4
5
1
3
x4 =21− x2 − x3 + x6
4
2
4
1
3
x5 = 6− x2 − 4x3 + x6
2
2
B = {1, 4, 5}, N = {2, 3, 6}
Neue Basislösung ist (9, 0, 0, 21, 6, 0)
Erhöhe x3 :
• in Gleichung für x1 : maximal auf 18
• in Gleichung für x4 : maximal auf
42
5
• in Gleichung für x5 : maximal auf
3
2
Vertausche x5 und x3 : x3 =
1
1
3 3
− x2 − x5 + x6 . Neues LP wie folgt:
2 8
4
8
111 1
1
11
+ x2 − x5 − x6
4
16
8
16
1
5
33 1
− x2 + x5 − x6
x1 =
4 16
8
16
3
1
1
3
− x2 − x5 + x6
x3 =
2
8
4
8
5
1
69 3
+ x2 + x5 − x6
x4 =
4 16
8
16
z=
Erhöhe x2 :
• in Gleichung für x1 : maximal auf 132
• in Gleichung für x3 : maximal auf 4
• in Gleichung für x4 : ∞
3.2. SIMPLEX-ALGORITHMUS
67
8
2
1
Vertausche x3 und x2 : x2 = 4 − x3 − x5 − x6 Neues LP wie folgt:
3
3
3
1
2
1
z =28− x3 − x5 − x6
6
6
3
1
1
1
x1 = 8+ x3 + x5 − x6
6
6
3
8
2
1
x2 = 4− x3 − x5 + x6
3
3
3
1
1
x4 =18− x3 + x5
2
2
3.2.2
Formaler Simplex-Algorithmus
Zunächst Hilfsprozedur:
Algorithmus Pivot(N, B, A, b, c, v, α, η)
Eingabe: Tupel (N, B, A, b, c, v, α, η) mit (N, B, A, b, c, v) Simplex-Normalform und Indizes α ∈
B, η ∈ N (xα Austrittsvariable, xη Eintrittsvariable)
Ausgabe: Simplex-Normalform (N ′ , B ′ , A′ , b′ , c′ , v ′ )
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
b′η := bα /aαη
for j ∈ N \ {η}
do a′ηj := aαj /aαη od
1
′
aηα := aαη
for i ∈ B \ {α} do
b′i := bi − aiη b′η
for j ∈ N \ {η}
do a′ij := aij − aiη a′ηj od
′
aiα := −aiη a′ηα
od
v ′ := v + cη b′η
for j ∈ N \ {η}
do c′j := cj − cη a′ηi od
′
cα := −cη a′ηα
N ′ := {α} ∪ N \ {η}
B ′ := {η} ∪ B \ {α}
return (N ′ , B ′ , A′ , b′ , c′ , v ′ )
Algorithmus 14: Pivot
Zeilen 1– 4
Zeilen 5–10
Zeilen 11–14
Umstellung der Gleichung für xα nach xη (ausg. bzgl. A, b)
Berechnung restlicher Koeffizienten (ausg. bzgl. A, b)
Berechnung der Zielfunktion (ausg. bzgl. A, b, c)
Algorithmus Pivot erfüllt folgende Invariante:
Ist (N, B, A, b, c, v, α, η) mit aαη 6= 0 die Eingabe für Pivot und (N ′ , B ′ , A′ , b′ , c′ , v ′ ) Ausgabe von
Pivot, und ist x̂ eine Basislösung nach Abarbeitung von Pivot, so gilt:
68
KAPITEL 3. LINEARE PROGRAMMIERUNG
1. x̂j = 0 für alle j ∈ N ′
2. x̂η =
bα
aαη
3. x̂i = bi − aiη b′η für alle i ∈ B ′ \ {η}
Mögliche Probleme für Simplex-Algorithmus:
1. Wie Erfüllbarkeit des LP testen?
2. Wie erste Basislösung finden, falls LP erfüllbar?
3. Wie Unbeschränktheit eines LP feststellen?
4. Wie Austritts- und Eintrittsvariablen bestimmen?
Behandlung der ersten beiden Probleme später. Wir nehmen an, wir hätten eine Prozedur
InitializeSimplex:
Eingabe: LP (A, b, c) in Standardform
Ausgabe: Simplex-Normalform (N, B, A, b, c, v), so dass Basislösung zulässig, wenn LP erfüllbar; sonst Fehlermeldung
3.2. SIMPLEX-ALGORITHMUS
69
Algorithmus Simplex(A, b, c)
Eingabe: LP (A, b, c) in Standardform
Ausgabe: optimale Lösung
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
(N, B, A, b, c, v) = InitializeSimplex(A, b, c)
while es gibt j ∈ N mit cj > 0 do
wähle η ∈ N mit cη > 0
for i ∈ B do
if aiη > 0
then ∆i := abiηi
else ∆i := ∞
fi
od
Bestimme α ∈ B mit ∆α minimal
if ∆α = ∞
then return LP unbeschränkt“
”
else (N, B, A, b, c, v) := Pivot(N, B, A, b, c, v, α, η)
fi
od
for i := 1 to n do
if i ∈ B
then x∗i := bi
else x∗i := 0
fi
od
return (x∗1 , . . . , x∗n )
; auf Seite 76
; auf Seite 67
Algorithmus 15: Simplex
3.2.3
Terminierung
Lemma 27:
Es sei (A, b, c) ein LP. Der Algorithmus InitializeSimplex gebe SNF für (A, b, c) zurück, so dass
die Basislösung zulässig ist. Wenn Algorithmus Simplex stoppt, so gibt er eine zulässige Lösung
für (A, b, c) zurück oder, falls (A, b, c) unbeschränkt ist, die Ausgabe LP unbeschränkt“.
”
Beweis: Wir zeigen mittels Induktion, dass vor jedem Schleifendurchlauf (Zeilen 2–15) folgende
Invarianten gelten:
(I1) Aktuelle SNF ist äquivalent zur initialen SNF
(I2) Für i ∈ B gilt bi ≥ 0.
(I3) Basislösung für aktuelle SNF ist zulässig.
Induktion über Anzahl i der Schleifendurchläufe.
70
KAPITEL 3. LINEARE PROGRAMMIERUNG
(IA) Es sei i = 0. D.h. Schleife wird zum ersten Mal durchlaufen. Invarianten gelten sofort
wegen Annahme über InitializeSimplex.
(IS) Es sei i > 0.Wir nehmen an, dass Zeile 12 nicht ausgeführt wird. (Behandlung später).
Betrachten Invarianten einzeln:
zu (I1): SNF wird nur in Zeile 13 verändert, mittels Vertauschung von Basis- und Bichtbasisvariablen (Koordinatentransformation). Damit wird SNF in äquivalente SNF umgeformt. Nach (IV) gilt (I1).
zu (I2): Es gelte bi ≥ 0 für alle i ∈ B (vor Schleifendurchlauf) nach (IV). Veränderung erfolgt
nur in Zeile 13. Es sei b̂ Vektor nach Ausführung von Zeile 13. Es gilt:
α
(a) b̂η ≥ 0 wegen b̂η = abαη
bα ≥ 0
aαη ≥ 0
nach Zeile 1 von Pivot auf Seite 67
nach (I2)
nach Zeile 5
nach Zeile 6 von Pivot
(b) Für i ∈ B \ {α} gilt: b̂i = bi − aiη b̂η
α
= bi − aiη ( abαη
nach Zeile 1 von Pivot
Unterscheide zwei Fälle:
α
≤ abiηi wegen Minimalität in Zeile 10.
i. Es sei aiη > 0. Dann gilt für α: abαη
α
= bi − aiη abiηi = 0
Somit: b̂i = bi − aiη abαη
ii. Es sei aiη ≤ 0. Damit b̂i ≥ 0 wegen bi ≥ 0, bα ≥ 0, aαη ≥ 0.
zu (I3): Folgt aus (I2).
Betrachten nun noch den Terminierungszeitpunkt:
Ausgabe entweder in Zeile 22 oder in Zeile 12.
1. Ausgabe in Zeile 22. D.h. Schleifenbedingung in Zeile 2 nicht erfüllt. Zulässigkeit der ausgegebenen Lösung folgt aus (I1), (I2), (I3).
2. Ausgabe in Zeile 12. D.h. es gilt aiη ≤ 0 für alle i ∈ B. Es sei x = (x1 , . . . , xn+m ) die
Basislösung. Betrachte für k ≫ 0 folgende Lösung:


, falls i = η
k
x̂i =def 0
, falls i ∈ N \ {η}

P

b − j∈N aij x̂j , falls i ∈ B
Zeigen, dass x̂i ≥ 0 für alle i ∈ N ∪ B.
(a) Ist i ∈ N , dann x̂i ≥ 0
(b) Ist i ∈ B, dann x̂i = bi − aiη x̂η ≥ 0 wegen bi ≥ 0 (I2), aiη ≤ 0, x̂η ≥ 0
D.h. x̂ ist zulässige Lösung für alle k > 0. Für Zielfunktion gilt:
z=v+
X
j∈N
k→∞
cj x̂j = v + cη x̂η = v + cη k → ∞
wegen cη > 0. D.h. LP unbeschränkt.
3.2. SIMPLEX-ALGORITHMUS
71
Müssen nun zeigen: Simplex terminiert.
Problem dabei: Kreisvertauschungen; können auftreten bei Degenerizität, d.h. Vertauschungen
lassen Zielwert unverändert.
Simplex-Algorithmus zirkuliert auf LP (A, b, c), falls für zwei verschiedene Schleifendurchläufe
die Mengen der Basisvariablen übereinstimmen.
Lemma 28:
Es sei (A, b, c) ein LP der Dimension m × n. Falls der Algorithmus Simplex in
durchläufen nicht terminiert, dann zirkuliert Simplex.
n+m
m
Schleifen-
Beweis: Nach Lemma 26 auf Seite 63 ist SNF eindeutig für eine Menge von Basisvariablen. Es
gilt kBk = m, kN ∪ Bk = n + m. Damit gibt es höchstens n+m
verschiedene Mengen für B,
m
also höchstens n+m
verschiedene
äquivalente
SNF.
m
Zirkulieren kann vermieden werden:
1. Störe LP geringfügig, um gleichen Zielwert zu vermeiden
2. Bland-Regel: Bei Gleichheit in Zeilen 3 unf 10 wähle stets Variable mit kleinstem Index.
Lemma 29:
Wird in Zeilen 3 und 10 des Algorithmus Simplex die Bland-Regel verwendet, so stoppt Simplex
für alle Eingaben.
Satz 30:
Es sei (A, b, c) ein LP der Dimension m × n. Gibt InitializeSimplex eine SNF für (A, b, c) zurück,
so dass Basislösung zulässig ist, so gibt Simplex LP unbeschränkt“
zurück, falls (A, b, c) unbe
”
schränkt, oder eine zulässige Lösung in höchstens n+m
Schleifendurchläufen.
m
Beachte:
3.2.4
n+m
m
22n
≈ √
2n
Optimalität und Dualität
Wollen zeigen, dass Simplex optimale Lösung bestimmt, falls eine existiert.
Es sei (A, b, c) ein LP in Standardform. Dann heißt das LP
Minimiere
bT y
bezüglich
AT y ≥ c
y≥ 0
Pm
(bzw. Minimiere P i=1 bi yi
m
bezüglich
i=1 aij yi ≥ cj für j ∈ {1, . . . , n})
das duale LP zu (A, b, c). Das LP (A, b, c) heißt primales LP.
Lemma 31:
Es sei (A, b, c) ein LP. Es seien x̄ eine zulässige Lösung für (A, b, c) und ȳ eine zulässige Lösung
72
KAPITEL 3. LINEARE PROGRAMMIERUNG
für das duale LP zu (A, b, c). Dann gilt:
n
X
j=1
m
X
cj x̄j ≤
Bi ȳi
i=1
Beweis: Es gilt:
n
X
cj x̄j
j=1
n
duales LP X
≤
j=1
=
m
X
i=1
primales LP
≤
m
X
m
X
aij ȳi
i=1
!
x̄j


n
X

aij x̄j  ȳi
j=1
bi ȳi
i=1
Korollar 32:
Es sei (A, b, c) ein LP. Es seien x̄ zulässige Lösung für primales LP und ȳ zulässige Lösung für
duales LP. Gilt
m
n
X
X
bi ȳi ,
cj x̄j =
i=1
j=1
so sind x̄ und ȳ optimale Lösungen für das primale bzw. duale LP.
Simplex-Algorithmus berechnet gleichzeitig beide Lösungen!
Die letzte SNF, die Simplex berechnet, sei
z =v ′ +
X
c′j xj
j∈N
xi =b′i
−
X
j∈N
a′ij xj für i ∈ B
Simplex bestimmt für primales LP (j ∈ {1, . . . , n})
x̄j =
(
0
bj
, falls j ∈ N
, falls j ∈ B
Wir setzen für das duale LP an: (i ∈ {1, . . . , m})
ȳj =def
(
0
−cn+i
, falls n + i ∈ N
, falls n + i ∈ B
(*)
3.2. SIMPLEX-ALGORITHMUS
73
Beispiel: SNF n = 3, m = 3
1
2
1
z =28− x3 − x5 − x6
6
6
3
1
1
1
x1 = 8+ x3 + x5 − x6
6
6
3
8
2
1
x2 = 4− x3 − x5 + x6
3
3
3
1
1
x4 =18− x3 + x5
2
2
c = (3, 1, 2)
b = (30, 24, 36)
1 2
ȳ T = (0, , )
6 3
x̄T = (8, 4, 0)
z = cT x̄ = 28
z = bT ȳ = 30 · 0 + 24 ·
1
2
+ 36 · = 28
6
3
Satz 33:
Es sei (A, b, c) das primale LP. Der Algorithmus Simplex gebe auf (A, b, c) die Lösung x̄ zurück.
Weiterhin seien N und B die Nichtbasis- bzw. Basisvariablen der letzten SNF. Dann ist der in
(∗) definierte Vektor eine zulässige Lösung für das duale LP und es gilt
n
X
m
X
cj x̄j =
bi ȳi
i=1
j=1
D.h. x̄ ist optimale Lösung für das primale LP.
Beweis: Wir nehmen an, dass Simplex in Zeile 22 Lösung zurückgibt. Dann gilt für die letzte
SNF
z = v′ +
X
j∈N
c′j xj mit c′j ≤ 0 für alle j ∈ N
Wir setzen c′j = 0 für alle j ∈ B. Dann gilt:
′
z=v +
X
c′j xj
′
=v +
n+m
X
c′j xj
j=1
j∈N
Betrachten Basislösung x̄ mit x̄j = 0 für j ∈ N . Es gilt:
n
X
cj x̄j = v ′ +
n+m
X
c′j x̄j
j=1
j=1
= v′ +
X
j∈N
= v′
c′j · 0 +
(1)
X
j∈B
0 · x̄j
Beachte: Gleichung (1) gilt für alle Belegungen x = (x1 , . . . , xn ) wegen Äquivalenz aller SNF.
74
KAPITEL 3. LINEARE PROGRAMMIERUNG
1. Zeigen Optimalität, d.h.
n
X
m
X
cj x̄j =
n
X
bi ȳi . Es gilt für alle x = (x1 , . . . , xn ):
i=1
j=1
(1)
cj xj = v ′ +
n+m
X
c′j xj
j=1
j=1
=v ′ +
n
X
c′j xj +
=v ′ +
c′j xj +
Def. von ȳ ′
=v +
c′j xj +
=v +
n
X
c′j xj +
=v ′ +
=v ′ +
j=1
n
X
j=1
′
= v −
m
X
i=1
j=1
n
X
m
X
i=1
j=1
Def. von Schlupfvar. ′
m
X
i=1
j=1
n
X
c′j xj
n+1
j=1
n
X
n+m
X
c′j xj −
c′j xj −
m
X
bi ȳi
i=1
m
X
i=1
m
X
cn+i ·′ xn+i
(−ȳi ) · xn+i

(−ȳi ) · bi −
bi ȳi +
bi ȳi +
+
j=1
m X
n
X
i=1 j=1
n X
m
X
n
X
j=1
c′j
+
m
X

aij xj 
(aij xj )ȳi
(aij ȳi )xj
j=1 i=1
i=1
!
n
X
aij ȳi
i=1
!
xj
Nach Lemma 25 auf Seite 62 gilt somit:
v′ −
c′j +
m
X
i=1
Aus (∗∗) folgt:
m
X
bi ȳi = v ′ =
bi ȳi = 0
(**)
i=1
m
X
n
X
aij ȳi = cj für j ∈ {1, . . . , n}
(***)
cj x̄j , d.h. x̄ optimale Lösung.
j=1
i=1
2. Zulässigkeit von ȳ für duales LP; d.h. müssen zeigen ȳ ≥ 0 und
j ∈ {1, . . . , n}:
m
X
i=1
aij ȳi ≥ cj für alle
• ȳ ≥ 0 folgt aus c′j ≤ 0 für alle j ∈ N .
• Wegen (∗ ∗ ∗) folgt:
m
X
′
aij ȳj = cj − cj ≥ cj für alle j ∈ {1, . . . , n}
|{z}
i=1
≤0
| {z }
≥0
3.2. SIMPLEX-ALGORITHMUS
3.2.5
75
Initialisierung
Ziel: Wie sieht InitializeSimplex aus?
Beispiel: LP P1 (in Standardform)
Maximiere 2x1 + x2
bezüglich 2x1 − x2 ≤ 2
x1 −5x2 ≤ −4
x1 , x2 ≥ 0
z = 0+2x1 + x2
x3 = 2−2x1 + x2
x4 =−4− x1 +5x2
Basislösung“ (0, 0, 2, −4) nicht zulässig!
”
Ausweg: Betrachte lineares Hilfsprogramm zu gegebenem LP.
Es sei P = (A, b, c) ein m × n-dimensionales LP. Dann ist das Hilfsprogramm Paux definiert
wie folgt: Maximiere −x0
n
X
aij xj − x0 ≤ bi für alle i ∈ {1, . . . , m}
bezüglich
j=1
xj ≥ 0
Bemerkungen:
1. Dimension von Paux ist m × (n + 1)
2. LP Paux ist immer erfüllbar; z.B. xj = 0 für j ∈ {1, . . . , n}, x0 = |mini∈{1,...,n} bi |
Lemma 34:
Ein LP P (in Standardform) ist erfüllbar gdw. zugehöriges LP Paux besitzt den optimalen Zielwert
0.
Beweis: Es sei P = (A, b, c) ein beliebiges LP.
⇒ Es sei x̄ = (x̄1 , . . . , x̄n ) eine zulässige Lösung für P . Dann gilt für x̄0 = 0:
1. bi ≥
n
X
j=1
aij x̄j = −x̄0 +
2. x̄0 , x̄1 , . . . , x̄n ≥ 0.
n
X
aij x̄j
j=1
∗
∗
Somit ist (0, x̄1 , . . . , x̄n ) zulässig für Paux . zaux
≤ 0 = −x̄0 ≤ zaux
76
KAPITEL 3. LINEARE PROGRAMMIERUNG
∗
⇐ Es gelte zaux
= 0. D.h. x∗0 = 0. Rest analog zu ⇒ .
Algorithmus InitializeSimplex(A, b, c)
Eingabe: LP (A, b, c) in Standardnormalform
Ausgabe: SNF (N, B, A, b, c, v), so dass Basislösung zulässig ist, falls LP erfüllbar; sonst Fehlermeldung
1
2
3
4
5
6
7
8
9
10
11
Bestimme α mit bα minimal
if bα ≥ 0
then return ({1, . . . , n}, {n + 1, . . . , n + m}, A, b, c, 0) fi
Bestimme Paux
(N, B, A, b, c, v) :=SNF von Paux
(N, B, A, b, c, v) := Pivot(N, B, A, b, c, v, α, 0)
; auf Seite 67
Führe Zeilen 2–15 von Simplex aus, bis optimale Lösung gefunden ist
; auf Seite 69
if x∗0 = 0 in finaler Basislösung
then return Finale SNF mit x0 entfernt und Zierlfunktion wieder hergestellt
else return LP unerfüllbar“
”
fi
Algorithmus 16: InitializeSimplex
Beispiel: betrachte Hilfsprogramm zu LP P1 auf der vorherigen Seite
z = 0− x0
x3 = 2+ x0 − 2x1 + x2
x4 =−4+ x0 − x1 + 5x2
Nach Aufruf von Pivot in Zeile 6
z =−4− x1 + 5x2 − x4
x0 = 4+ x1 − 5x2 + x4
x3 = 6− x1 − 4x2 + x4
Beachte: Basislösung (4, 0, 0, 6, 0) ist nun zulässig. Führe Zeilen 2–15 von Simplex aus: Vertausche
x2 und x0 . Neue SNF:
z = 0− x0
4 1
1
1
x2 = − x0 + x1 + x4
5 5
5
5
9
1
14 4
x3 = + x0 − x1 + x4
5 5
5
5
SNF ist auch final, d.h. Basislösung (0, 0, 54 , 14
5 , 0) ergibt optimalen Zielwert 0, d.h. InitializeSimplex
3.2. SIMPLEX-ALGORITHMUS
77
erfibt folgende SNF zurück (z = 2x1 + x2 )
4 11
1
+ x1 + x4
5 5
5
1
1
4
x2 = + x1 + x4
5
5
5
9
1
14
x3 = − x1 + x4
5
5
5
z=
Lemma 35:
Es sei (A, b, c) ein LP.
1. Ist (A, b, c) nicht erfüllbar, so gibt Algorithmus InitializeSimplex LP unerfüllbar“ zurück.
”
2. Ist (A, b, c) erfüllbar, so gibt Algorithmus InitializeSimplex eine SNF mit zulässiger Basislösung zurück.
Beweis:
zu 1. Sei (A, b, c) uunerfüllbar. Nach Lemma 34 auf Seite 75 gilt für Hilfsprogramm z ∗ < 0. Außerdem ist optimaler Zielwert endlich (Belegung aus Bemerkung 2 ergibt −|mini∈{1,...,n} bi |),
d.h. Zeile 7 bestimmt negativen optimalen Zielwert, d.h. x∗0 6= 0 und InitializeSimplex gibt
LP unerfüllbar“ zurück.
”
zu 2. Betrachte Fall bα < 0 (anderer Fall klar). Müssen zeigen, dass nach Zeile 6 Basislösung für
Hilfsprogramm zulässig ist, d.h. alle b′i sind nicht negativ nach Pivot:
(
bi − aiη b′η , falls i ∈ (B \ {α}) \ {η}
′
bi = bα
, falls i = η
aαη
Es gilt η = 0 und ai,0 = −1 für alle i ∈ B. Damit ergibt sich:
(a) b′η =
bα
aαη
> 0, da bα < 0 und aαη < 0.
′
(b) für i ∈ B \ {η}:
b′i = bi − aiη b′η
bα
= bi − aiη
aαη
= bi − bα
≥0
Zeile 6 von Pivot
Zeile 1 von Pivot
da aiη = aαη = −1
da bα minimal
Somit ist nach Ausführung von Zeile 6 Basislösung immer zulässig. Da (A, b, c) erfüllbar
ist, findet Zeile 7 finale SNF mit Zielwert 0, d.h. x∗0 (da alle SNF äquivalenmt). Nach
Entfernung von x0 aus SNF entsteht SNF mit zulässiger Basislösung für (A, b, c)