10 K¨urzeste Pfade

10 Kürzeste Pfade
In diesem Kapitel setzen wir uns mit der Berechnung von kürzesten Pfaden in einem Graphen
auseinander.
Definition 10.1 (Pfadgewichte).
i) Das Gewicht eines Pfades p = (v0 , v1 , . . . , vk ) ist die Summe der Kantengewichte, die
zu den aufeinander folgenden Knotenpaaren gehören.
w(p) =
k
X
w(vi−1 , vi )
i=1
ii) Das Gewicht des kürzesten Pfades von s nach v ist definiert als
min{w(p)|s →p v}
falls ein Pfad existiert
δ(s, v) =
∞
sonst
iii) Der kürzeste Pfad p von s nach v ist ein Pfad mit minimalem Gewicht: w(p) = δ(s,v)
Beispiel 10.1.
Beispiel eines gewichteten Graphen anhand eines Städtenetz, dessen Kanten durch die Entfernung gewichtet sind. Das Gewicht des kürzesten Pfades von Hamburg nach Nürnberg ist z.B.:
δ(Hamburg,Nürnberg) = 700 km.
10.1 SSSP-Problem
Gegeben ein ungerichteter Graph G = (V,E) und eine Gewichtsfunktion w
w:E→R
Man berechne für einen vorgegebenen Knoten s die kürzesten Pfade zu allen anderen Knoten.
159
10 Kürzeste Pfade
Single-Destination Shortest Path (SDSP)
Gegeben ein ungerichteter Graph G = (V,E) und eine Gewichtsfunktion w
w:E→R
Man berechne für einen vorgegebenen Knoten s die kürzesten Pfade von allen anderen Knoten
zu v.
Lösung. Durch Umkehrung der Kantenrichtung führt man das SDSP-Problem auf ein SSSPProblem zurück.
Single-Pair Shortest Path (SPSP)
Gegeben ein ungerichteter Graph G = (V,E) und eine Gewichtsfunktion w
w:E→R
Man berechne für eine vorgegebenes Knotenpaar (s,v) den kürzesten Pfad von s nach v.
Lösung. Durch Anwendung des SSSP-Problems auf s erhält man alle kürzesten Pfade, also
auch den kürzesten Pfad nach v.
All-Pair Shortest Path (APSP)
Gegeben ein ungerichteter Graph G = (V,E) und eine Gewichtsfunktion w
w:E→R
Man berechne für jedes Knotenpaar (s,v) den kürzesten Pfad von s nach v.
Lösung. Durch Anwendung des SPSP-Problems auf alle Knotenpaare erhält man die Lösung
dieses Problems. Es gibt jedoch effizientere Verfahren, die nicht auf SPSP basieren.
Lemma 10.1 (Teilpfade von kürzesten Pfaden sind kürzeste Pfade). Gegeben ein gewichteter Graph G = (V,E) mit Gewichtsfunktion w : E → R.
Sei p = (v1 , v2 , . . . , vk ) ein kürzester Pfad von Knoten v1 nach vk und sei für jedes Paar i,j mit
1 ≤ i ≤ j ≤ k pij = (vi , vi+1 , . . . , vj ) der Teilpfad von Knoten vi nach Knoten vj .
Dann ist pij ein kürzester Pfad von vi nach vj .
Beweis.
w(p) = w(p1i ) + w(pij ) + w(pjk )
Annahme: pij ist nicht der kürzeste Pfad von vi nach vj .
0
0
Damit folgt, daß es einen Pfad pij gibt, mit w(pij ) < w(pij )
0
⇒
w(p) = w(p1i ) + w(pij ) + w(pjk ) > w(p1i ) + w(pij ) + w(pjk )
Damit haben wir einen kürzeren Pfad gefunden als p.
160
E
10.2 Bellman-Ford Algorithmus
Anmerkung 10.1. Die Gewichtsfunktion w : E → R kann Kanten auch negative Gewichte
zuordnen. Unter diesen Umständen spielen Kreise bzw. Rundgänge mit negativem Gesamtgewicht eine besondere Rolle.
Falls es einen negativen Zyklus auf dem Pfad gibt, dann ist der kürzeste Pfad nicht wohldefiniert, da man durch Hinzufügen weiterer Zyklusrunden das Pfadgewicht beliebig klein machen
kann (in unserem Beispiel wäre dies der Pfad (s,e,f,e,f,e,f,. . . ) ). In diesem Fall setzt man das
Gewicht des kürzesten Pfades δ(s, g) = −∞.
Lemma 10.2. Gegeben ein gewichteter Graph G = (V,E) mit |V | = n und |E| = m. Findet
man zwei kürzeste Pfade mit gleichem Gewicht aber unterschiedlicher Anzahl an Kanten,
betrachten wir nur den kürzesten Pfad mit der kleineren Anzahl an Kanten. Dann gilt:
Die gesuchten kürzesten Pfade enthalten höchstens n Knoten und n-1 Kanten.
Beweis.
Wir zeigen: Es kommen keine Zyklen in den gesuchten kürzesten Pfaden vor.
i) Zyklen mit negativem Gewicht: Wie in Anm. 10.1 gezeigt, existiert kein wohldefinierter
kürzester Pfad.
ii) Zyklen mit Gewicht größer 0: Findet man einen Pfad mit einem Zyklus, so verkleinert
man das Gesamtgewicht durch Entfernen dieses Zyklus aus dem Pfad.
iii) Zyklen mit Gewicht 0: Durch Streichen des Zyklus aus dem Pfad verändert sich nicht
das Gesamtgewicht, aber die Anzahl der Kanten des Pfades verkleinert sich. Nach Voraussetzung betrachten wir damit nur den Pfad mit der kleineren Anzahl der Kanten.
Also gilt, daß keine Zyklen im gesuchten kürzesten Pfad vorkommen, der kürzeste Pfad jeden
Knoten nur einmal enthalten kann. Somit folgt die Behauptung.
10.2 Bellman-Ford Algorithmus
In diesem Abschnitt wird der Bellman-Ford Algorithmus zur Lösung des SSSP-Problems
vorgestellt. Dieser Algorithmus verwendet eine Relaxationstechnik, die an dieser Stelle eingeführt werden soll.
161
10 Kürzeste Pfade
Definition 10.2 (Relaxation). Eine Kante (u,v) zu entspannen (relaxieren), bedeutet, daß man
einen Test durchführt, ob man einen neuen kürzesten Pfad von s nach v erhält, wenn man den
aktuell kürzesten Pfad von s nach u betrachtet und die Kante (u,v) hinzufügt.
Zur Berechnung benötigen wir spezielle Datenstrukturen:
• Die Gewichte der Kanten werden in einem Kantenfeld gespeichert.
Kantenfeld<float> gewicht
• Die Gewichte der aktuell kürzesten Pfade zu den Knoten werden in einem Knotenfeld
gespeichert.
Knotenfeld<float> länge
• Die Vorgängerknoten auf den aktuell kürzesten Pfaden zu den Knoten werden in einem
Knotenfeld gespeichert.
Knotenfeld<Knoten> vorgänger
Mit Hilfe dieses Feldes kann man den kürzesten Pfad zu einem Knoten v bestimmen.
Solange man den kürzesten Pfad von s zu einem Knoten v noch nicht gefunden hat, speichert
man in länge[v] eine obere Schranke für die Länge des kürzesten Pfades von s nach v.
Die Knoten werden am Start wie folgt initialisiert (Initialisiere(G,s)):
Für alle Knoten v in E\{s}:
länge[v] = infinity
Für alle Knoten v in E:
vorgänger[v] = nil
länge[s] = 0
Relax(e,gewicht,länge,vorgänger):
(1) hilfe = länge[quelle(e)] + gewicht[e]
(2) Falls länge[ziel(e)] > hilfe
(3)
länge[ziel(e)] = hilfe
(4)
vorgänger[ziel(e)] = quelle(e)
Lemma 10.3 (Eigenschaften der Pfad Relaxation). Falls p = (v0 , v1 , . . . , vk ) ein kürzester
Pfad von s = v0 nach vk ist und die Kanten von p in der Reihenfolge (v0 ,v1 ), (v1 ,v2 ), . . .
(vk−1 ,vk ) relaxiert werden, dann gilt:
länge[vk ] = δ(s, vk )
Diese Eigenschaft gilt unabhängig von anderen Relaxationsschritten, die eventuell vorher,
nachher oder auch zwischendurch ausgeführt werden.
162
10.2 Bellman-Ford Algorithmus
Beweis. [mittels vollständiger Induktion]
Induktionsannahme: Nach der Relaxation von (vi−1 ,vi ) gilt:
länge[vi ] = δ(s, vi )
Induktionsstart: i=0:
länge[s] = 0 = δ(s,s)
Induktionsschluß: Die Induktionsannahme gelte ∀ k < i. Damit folgt:
δ(s, vi ) =
=
i
X
k=1
i−1
X
w(vk−1 , vk )
w(vk−1 , vk ) + w(vi−1 , vi )
k=1
= δ(s, vi−1 ) + w(vi−1 , vi )
= länge[vi−1 ] + w(vi−1 , vi )
= länge[vi ]
Mit diesem Wissen können wir nun den Bellman-Ford Algorithmus im Pseudocode vorstellen:
Bellman-Ford(G,w,s):
(1)
(2)
(3)
(4)
(5)
(6)
(7)
Initialisiere(G,s)
Für alle i = 1, . . . ,n-1:
Für alle Kanten e = (u,v)∈E: Relax(e,w,länge,vorgänger)
Für alle Kanten e = (u,v):
Falls länge[v] > länge[u] + w[e]
Gib FALSE zurück
Gib TRUE zurück
Der Bellman-Ford Algorithmus löst den allgemeinen Fall des SSSP-Problems, d.h. negative
Kantengewichte sind erlaubt. Der Rückgabewert ist eine boolsche Variable, die angibt ob erfolgreich alle kürzesten Pfade zu den von s aus erreichbaren Knoten bestimmt wurden oder
ein negativer Zyklus gefunden wurde.
Laufzeit des Algorithmus
Im Folgenden wollen wir uns die Laufzeit des Bellman-Ford-Algorithmus näher ansehen.
Satz 10.1 (Laufzeit des Bellman-Ford-Algorithmus).
Der Bellman-Ford-Algorithmus hat eine Laufzeit O(nm), wobei |V| = n und |E| = m.
163
10 Kürzeste Pfade
Beweis. Die Initialisierung läuft in Θ(V) ab. In Zeile 4 wird für alle |V|-1 Durchläufe O(E)
Zeit benötigt. Schließlich wird die Schleife von Zeile 4-6 in O(E) Zeit durchlaufen. Damit
folgt die Behauptung.
Lemma 10.4. Sei G = (V,E) ein gewichteter und gerichteter Graph mit Quelle s und Gewichtsfunktion w : E → R. Enthält der Graph G keine negativen Zyklen, die von s aus erreicht
werden können, dann berechnet der Algorithmus die Gewichte (Längen) der kürzesten Pfade
korrekt, d.h., für alle erreichbaren Knoten gilt:
länge[v] = δ(s,v)
Beweis. Sei v ∈ V erreichbar von s und sei p = (v0 , . . . ,vk ) mit s = v0 und v = vk ein azyklischer, kürzester Pfad von s nach v. Der Pfad p hat höchstens n-1 Kanten. Daher ist k<n. In
Zeile 2 und 3 wird jede Kante in jeder der n-1 Iterationen relaxiert. Unter den Kanten, die in
der i-ten Iteration entspannt werden, ist auch (vi−1 ,vi ). Aus Lemma 10.3 folgt daher:
länge[v] = länge[vk ] = δ(s,vk ) = δ(s,v)
Beweis der Korrektheit des Bellman-Ford-Algorithmus.
Angenommen der Graph G enthält keine negativ gewichteten Zyklen, die von s aus erreichbar
sind. Nach der Terminierung gilt ∀v ∈ V: länge[v] = δ(s,v). Nach Lemma 10.4 gilt diese
Aussage, wenn v von s erreichbar ist. Falls v nicht von s erreichbar ist, folgt die Behauptung
aus Lemma 10.3. Der Vorgängergraph Gp = (Vp , Ep ) zum Graphen G = (V,E) mit
Vp = {v ∈ V |vorgänger[v] 6= nil} ∪ {s}
Ep = {(vorgänger[v], v) ∈ E|v ∈ Vp }
ist ein kürzester-Pfad Baum. Der Beweis wird als leichte Fingerübung dem Leser überlassen.
Bei der Terminierung des Algorithmus gilt ∀(u,v) ∈ E:
länge[v] = δ(s, v)
≤ δ(s, u) + w(u, v)
= länge[u] + w(u, v)
Damit folgt, dass in Zeile 5 keiner der Tests dazu führt, daß FALSE zurückgegeben wird, also
liefert er Algorithmus TRUE zurück. Umgekehrt, nehmen wir daß G einen negativ gewichteten
Zyklus z = (v0 ,v1 . . . ,vk ) mit v0 = vk enthält, der von s aus erreichbar ist. Damit gilt:
k
X
w(vi−1 , vi ) < 0
i=1
Annahme: Der Bellman-Ford Algorithmus liefert TRUE zurück.
Damit folgt: δ[vi ] ≤ länge[vi−1 ] + w(vi−1 , vi )f üri = 1, 2, . . . , k
164
(10.1)
10.3 Der Algorithmus von Dijkstra
Summieren wir nun diese Ungleichungen entlang des Zyklus z, erhalten wir
k
X
länge[vi ] ≤
i=1
k
X
länge[vi−1 ] +
i=1
k
X
w(vi−1 , vi )
i=1
Da jeder Knoten in z exakt einmal in jedem der ersten beiden Summen vorkommt, gilt:
k
X
länge[vi ] =
i=1
k
X
länge[vi−1 ]
i=1
Da der Algorithmus nur terminiert, wenn länge[vi ] < ∞ ∀i = 1, 2, . . . , k gilt:
0≤
k
X
w(vi−1 , vi )
i=1
was der Ungleichung 10.1 widerspricht.
Damit folgt, daß der Bellman-Ford Algorithmus TRUE zurückliefert, wenn der Graph G keine
negativ gewichteten Zyklen enthält, die von der Quelle erreichbar sind, sonst FALSE.
10.3 Der Algorithmus von Dijkstra
In diesem Abschnitt wird der Dijkstra-Algorithmus zur Lösung des SSSP-Problems für gerichtete Graphen mit Gewichtsfunktionen, die den Kanten nur positive Kantengewichten zuordnen
vorgestellt.
Dijkstra(G,w,s):
(1)
(2)
(3)
(4)
(5)
(6)
(7)
(8)
Initialisiere(G,s)
S = ∅
Q = V
Solange Q 6= V
u = Extrakt-Minimum(Q)
S = S ∪ {u}
Für jede Kante e = (u,v)∈E, die u verlässt:
Relax(e,w,länge,vorgänger)
Der Algorithmus verwaltet eine Knotenmenge S, für die bereits ein kürzester Pfad von der
Quelle s aus identifiziert wurde.
Aus der restlichen Knotenmenge V\S wählt man in jeder Iteration den Knoten u mit dem
kleinsten gespeicherten Wert für den aktuell kürzesten Pfad, addiert u zu S und entspannt alle
Kanten, die u verlassen.
165
10 Kürzeste Pfade
Satz 10.2 (Korrektheit des Dijkstra-Algorithmus). Der Algorithmus von Dijkstra berechnet
für einen gewichteten und gerichteten Graphen G = (V,E), eine Gewichtsfunktion w : E → R
mit nicht negativen Gewichten und eine Quelle s die kürzesten Pfade von s zu allen erreichbaren Knoten v ∈V korrekt. D.h.
länge[v] = δ(s, v)
Beweis. Wir beweisen die folgende Invariante für die Iteration: Am Start jeder Iteration in der
Solange“-Schleife gilt für alle Knoten v ∈ S: länge[v] = δ(s,v)
”
Es genügt dies für alle zu S hinzugefügten Knoten zu zeigen.
Initialisierung: S = ∅. Daher ist die Invariante erfüllt.
Aufrechterhaltung: Annahme: ∃u ∈ S mit länge[u] 6= δ(s, u)
Wir betrachten den Zeitpunkt zu dem u in S eingefügt wurde.
u 6= s und S 6= ∅
Es gilt:
Es muss ein Pfad, also auch einen kürzesten Pfad von s nach u geben, da sonst aufgrund
der Initialisierung länge[u] = δ(s, u) = ∞.
Bevor u zu S addiert wird, gilt:
s ∈ S und u ∈ V \S
Sei y der erste Knoten auf dem kürzesten Pfad p von s nach u, der zu diesem Zeitpunkt nicht zu S gehört und x sein Vorgänger in S. Damit zerlegen wir p in folgende
Komponenten:
p1
p2
s −→ x → y −→ u
Da x ∈ S ist und vor u in S eingefügt wurde, gilt für x: länge[x] = δ(s, x)
Als x zu S addiert wurde, wurde (x,y) entspannt.
⇒
länge[y] = länge[x] + w(x, y) = δ(s, x) + w(x, y) = δ(s, y)
Da y auf dem kürzesten Pfad von s nach u auftaucht und w(u, v) ≥ 0 ∀(u, v) ∈ E,
folgt:
δ(s, y) ≤ δ(s, u)
länge[y] = δ(s, y) ≤ δ(s, u) ≤ länge[u]
Da aber beide Knoten u und y in Q = V\S waren, als u als Knoten mit minimalem
Gewicht bestimmt wurde, gilt:
länge[y] = δ(s, y) = δ(s, u) = länge[u]
Da δ(s, u) = länge[u] erhalten wir einen Widerspruch zur Wahl von u.
Ende des Algorithmus: Am Ende ist Q = ∅ und S = V, so dass ∀v∈V
länge[v] = δ(s, v)
166
10.3 Der Algorithmus von Dijkstra
E
Im Folgenden wollen wir die Laufzeit des Dijkstra-Algorithmus betrachten.
Satz 10.3 (Laufzeit des Dijkstra-Algorithmus).
Die amortisierte Laufzeit des Dijkstra-Algorithmus für einen gerichteten Graphen G = (V,E)
mit |V| = n und |E| = m ist O(n log(n) + m).
Beweis. Implementiert man die Extrakt-Minimum(Q) mittels eines Fibonacci-Heap (siehe
Kap. ??), so kann man in Zeit O(log(n)) das Minimum extrahieren“. Damit läuft die Zeile 5
”
in O(n log(n)). Entspannt man eine Kante, so ändert sich eventuell der aktuell kürzeste Pfad
und man muss im Fibonacci-Heap eine Decrease-Key-Operation ausführen, die amortisierte
Zeit O(1) kostet. Also benötigen Zeile 6 O(n) und Zeile 8 O(m) Zeit, womit die behauptete
Laufzeit folgt.
167