Kürzeste Wege Problem

1. Kürzeste Wege Problem Das Ergänzende Kapitel zu DAP 2 Bernchteine Elena

2. Kürzeste Wege • In kantenbewerteten Graphen war die Distanz zwischen zwei Knoten definiert als die Länge des kürzesten Weges zwischen ihnen. • Gegeben sein ein Weg p= (v0,v1,...,vn) in einem Graphen G • mit Kantengewicht w . • Die Länge des Weges ist dann definiert als • w(p) =  n (vi-1 , vi) • i =1 • Bezeichnen wir mit P ( u,v ) die Menge der Wege von Knoten u nach Knoten v, so ist die Distanz zwischen u und v • ( u,v ) = min { w ( p ) p P ( u,v ) } falls P ( u,v ) ¹ Æ • ¥ sonst • Ein kürzester Weg p von u nach v ist dann ein Weg p ÎP (u,v) mit • w( p ) = (u,v).

3. Problemvarianten Das Problem der kürzesten Wege (KW-Problem) tritt in den folgenden Varianten auf: 1 1:1-KW-Problem (single-pair shortest-path problem) Gesucht ist der kürzeste Weg von einem Knoten u zu einem Knoten v. 2 1:n-KW-Problem (single-source shortest-path problem) Gesucht sind die kürzesten Wege von einem Quellknoten u zu allen anderen Knoten v. 3 n:1-KW-Problem (single-destination shortest-path problem) Gesucht sind die kürzesten Wege zu einem Zielknoten v von allen anderen Knoten u. 4 n:n-KW-Problem (all-pairs shortest-path problem) Gesucht sind kürzesten Wege zwischen allen Knoten des Graphen.

4. Anmerkungen: • Problem 3 kann auf Problem 2 zurückgeführt werden (und umgekehrt), indem die Richtung der Kanten vertauscht wird. In ungerichteten Graphen sind die beiden Probleme identisch • Eine Lösung für Problem 1 fällt Teil eines Lösung für Problem 2 ab. Außerdem ist kein spezifischer Algorithmus für Problem 1 bekannt, der asymptotisch schneller wäre als die besten Algorithmen für Problem 2

5. Kanten mit negativen Gewichten Kanten mit negativen Gewichten sind zwar untypisch für KW-Probleme, können jedoch gelegentlich vorkommen. Sie sind tolerierbar, solange keine vom Quellknoten erreichbare Zyklen negativer Länge entstehen.Ein kürzester Weg wäre dann nicht mehr wohldefiniert. Einige Algorithmen verlangen nichtnegative Gewichte, andere tolerieren sie, d.h. sie produzieren ein korrektes Ergebnis, solange keine negativen Zyklen auftreten.

6. Repräsentation kürzester Wege In der Regel interessiert man sich nicht nur für die Länge eines kürzesten Weges, sondern auch für den kürzesten Weg selbst. Bei dem 1:n - KW-Problem, das wir betrachten wollen, bietet sich wieder die Verwendung eines Feldes pred[ ] an, in dem für jeden Knoten v dessen Vorgänger u auf dem kürzesten Weg von einem Quellknoten s nach v gespeichert ist (vgl. Breitensuche) pred[ ] definiert einen Baum mit Wurzel s , der die kürzesten Wege zu allen anderen Knoten enthält. Wie wir sehen werden, genügen die kürzesten Wege dieser Baumstruktur.

7. Eigenschaften der KW-Bäume • Graph G=(V,E) –gewichtet, gerichtet; w : E  R –Gewichtsfunktion, • s – Quellknoten, G hat keine Zyklen negativer Länge • 1. Nach der Initialisierung führt man eine Reihenfolge von Relaxationsschritten an der Kanten von G so, dass s eine Wurzel ist und aus dieser Wurzel s einen gerooteten Vorgänger-Teilgraph Gpred entsteht. • 2. Nach der Initialisierung führt man eine Reihenfolge von Relaxationsschritten an der Kanten von G so, dass d[v]=( u,v ) ist für alle v aus V. Daraus folgt, unser Vorgänger-Teilgraph Gpred – ein gerooteter aus der Wurzel s KW-Baum .

8. Beispiel: Gerichteter Graph mit zwei unterschiedlichen KW-Bäumen mit Wurzel 0

9. Eigenschaften kürzester Wege Lemma: (Optimale Substruktur) Gegeben sei ein Graph G = (V,E) mit Kantengewicht w . Sei p = ( v0 ,v1, ...,vn) ein kürzester Weg von v0 nach vn. Sei pik= (vi , vi+1 ,... ,vk) mit 0 £ i £ k £ n ein Teilweg von p. Dann ist pik= (vi , vi+1 ,… ,vk) ein kürzester Weg von vinach vk. Beweis: Wenn wir p zerlegen in Teilwege p0i , pikund pkn ,dann gilt: w(p) =w( p0i) + w( pik) + w( pkn) Wir nehmen nun an, es gebe einen Weg p'ik von v0 nach vkmit w(p'ik) < w(pik) . Dann ist p'= p0i , pik , pkn ein Weg von v0 nach vnmit w(p') = w( p0i) + w(p'ik) + w( pkn) < w( p0i) + w( pik) + w( pkn) = w( p) Dies ist ein Widerspruch zur Annahme, dass p ein kürzester Weg ist .

10. Korollar: Gegeben sei ein gerichteter Graph G = (V,E) mit Gewichtsfunktion w : E R Angenommen , es gebe einen kürzesten Weg p von s nach v , der man so beschreiben kann : su v ( mit dem Knoten u und dem Weg p). Daraus folgt ,dass das Gewicht des KW von s nach v ist : ((s,v) – Distanz zwischen s und v (kürzester Weg von s nach v) (s,v ) = (s,u ) + w(u,v) Beweis: (s,v ) = w(p) = w(p ) + w(u,v) = (s,u ) + w(u,v) qed. P 

11. Lemma: • Gegeben sei ein Graph G = (V,E) mit Kantengewicht w und • einem Ausgangsknoten s . • Dann gilt für alle Kanten (u ,v ) ÎE : (s,v ) £ (s,u ) + w(u,v) • Beweis : • Es gibt einen KW von s nach v , aber nicht über u • (s,v ) < (s,u ) + w(u,v) ist. • 2. Es gibt einen KW von s nach v über diesen Knoten u : • (s,v ) = (s,u ) + w(u,v) qed. • 3. Es gibt keinen KW von s nach v entweder über diesen Knoten u oder nicht über diesen Knoten u : • (s,v ) < (s,u ) + w(u,v) ist. P‘

12. Relaxation Zum Begriff der Relaxation Wir verwenden während der Berechnung Schätzungen d(v) (obere Schranken) für die Distanz zwischen Anfangsknoten s und allen anderen Knoten v. Am Anfang werden alle oberen Schranken (mit Ausnahme von s) auf „unendlich“ gesetzt. Anschließend findet Schritt für Schritt ein Relaxationsvorgang statt: Es wird für eine Kante (u,v) geprüft, ob sich durch Berücksichtigung dieser Kante die bisher gefundene Distanz d(v) (d(v) =(s,v) )von s nach v „entspannt“. void relax(index u, index v) { if (d[v] > d[u] + w(u ,v)) d[v] = d[u] + w(u ,v); pred[v]=u;}

13. Eigenschaften der Relaxation • Nach der Relaxation an der Kante (u,v): d[v] <=d[u] + w(u,v). • Beweis: a)Vor der Relaxation d[v] <=d[u] + w(u,v) - d[v] bleibt nach der Relaxation unverändert. • b) Vor der Relaxation d[v] >d[u] + w(u,v) - nach der Relaxation • d[v] =d[u] + w(u,v) . qed • 2. d[v] = (s,v) =  • Das heißt, es gibt keinen KW zwischen s und v. • s u v - KW und Vor der Relaxation d[u] = (s,u) , daraus folgt nach der Relaxation d[v] = (s,v) . • Beweis: • Nach der Relaxation d[v] <=d[u] + w(u,v) • = (s,u) + w(u,v) • = (s,v) • Nach Def. d[v]>= (s,v) , daraus folgt d[v] = (s,v) . qed

14. Beispiel(Relaxation an der Kante (u ,v) ) Im Fall (a) d[v] > d[u] + w[u,v] ,  d[v]wird gewechselt Im Fall (b) d[v]  d[u] + w[u,v] ,  d[v] bleibt unverändert v u u v 2 2 9 5 5 6 u v v u 2 2 5 7 5 6 (a) (b)

15. Dijkstras Algorithmus Die verschiedenen Kürzeste-Wege-Algorithmen unterscheiden sich im wesentlichen in der Reihenfolge, in der Kanten zur Relaxation aufgegriffen werden. Dijkstras Algorithmus geht davon aus,dass alle Kantengewichte nichtnegativ sind. • Alle Knoten werden nach ihrer bisher gefundenen Distanz d(v) aufsteigend geordnet in einer geeigneten Datenstruktur Q gehalten (am besten Prioritätswarteschlange mit Heap). • Der nächste Knoten u wird aus Q entfernt und alle von ihm ausgehenden Kanten werden „relaxiert“. • Bei den Endknoten v der Kanten (Nachbarn von u) wird u als Vorgänger im KW-Baum eingetragen, falls sich die Distanz d(v) verringert hat, also (u,v) eine Baumkante wird • Der Vorgang wird solange wiederholt, bis Q leer geworden ist .

16. Komplexität von Dijkstras KW-Algorithmus • Jede remove-Operation der Prioritätenwarteschlange benötigt O(log|V|) Schritte. Insgesamt werden |V| dieser Operationen benötigt. • Der Aufbau des Heaps der Warteschlange kostet O(|V|) • Die Modifikation der d -Werte (relax) impliziert ein Umordnen des Heaps, das in O(log|V|) Schritten durchgeführt werden kann .Höchstens |E| dieser Operationen sind erforderlich. • Wir erhalten also O(|V| log|V| + |E| log|V|) = O((|V|+|E|) log|V|) = O(|E| log |V|)

17. Fords Algorithmus (Bellman-Ford) • Der KW-Algorithmus nach Ford setzt keine nichtnegativen Gewichte voraus. • Er benutzt ebenfalls das Relaxationsprinzip. Es wird also in jedem Iterationsschritt für jede Kante (u,v) geprüft,ob ihre Verwendung die Distanz vom Quellknoten v0 zu ihrem Endknoten v reduziert. Es wird so lange iteriert, bis keine Verbesserungen mehr möglich sind. • Bei Existenz negativer Zyklen würde dies bedeuten , dass der Algorithmus nicht stoppt. • Da jeder kürzeste Weg jedoch aus höchstens |V|-1 Kanten besteht, kann man sich überlegen, dass |V|-1 Iterationsphasen ausreichen, um kürzeste Wege zu berechnen (falls existent, d.h. vom Quellknoten zu ihrem Endknoten kann man höchstens |V|-1 Kanten besuchen , sonst haben wir einen Zyklus negativer Länge) • In jedem Iterationsschritt i entstehen Teillösungen, d.h. kürzeste Wege mit einer Kantenanzahl von i.

18. BELLMAN-FORD(G , w, s) 1 initialize - single - source(G, s) 2 for i ← 1 to |V [G] | - 1 3 do for each edge (u, v)E [G] 4 do Relax(u,v,w) 5 for each edge (u, v) E [G] 6 do ifd[v] > d[u] + w(u,v) 7 then return FALSE 8 return TRUE

19. BELLMAN-FORD shortest path (V, E, vo , p) { // berechne SSSP von vo zu allen anderen Knoten // falls es keine Zyklen negativer Länge gibt, gib aus „nicht gefunden“ // sonst gib aus „gefunden“ und p enthält den kürzesten Weg for (each v  V) { d[v] =  ; p[v] = undefined; } d [v0]= 0; for (index i = 1; i <|V| -1; i ++ ) { for (each edge (u, v) E[G] ) { if (d[v] > d[u] + w(u,v) ) // Relaxation { d[v] = d[u] + w(u,v) ; p[v] = u ; }} // falls vorkommen, p enthält einen kürzesten Weg for (each edge (u, v) E[G] ) // überprüfe für negative Gewichte { if (d[v] > d[u] + w(u,v)) return FALSE ; return TRUE; }}}

20. Beispiel (Bellman-Ford-Algorithmus für negative Gewichte)

21. Beispiel (Bellman-Ford-Algorithmus für negative Gewichte) 5 6  -2 6 -3 0 8 7 -4 2 7  7 9 für i =1 Wir betrachten die vom Quellknoten 0 ausgehenden Kanten w(0,1)= 6 und w(0,3)=7 d[1] = 6 und d[3] = 7

22. Beispiel (Bellman-Ford-Algorithmus für negative Gewichte) 1 2 1 2 5 6 5 4 6  -2 -2 6 6 -3 -3 0 8 7 0 8 7 -4 -4 2 2 7 7 2 7  7 9 9 4 3 4 3 für i = 2 Wir betrachten die vom Quellknoten 0 über einen Zwischenort ausgehende Kanten w(0,1) , w(1,4) und w(0,3),w(3,2) d[4] = d[1]+ w(1,4)= 6+(-4)=2 und d[2] = d[3]+ w(3,2) =7+(-3)=4

23. Beispiel (Bellman-Ford-Algorithmus für negative Gewichte) 1 2 1 2 5 5 6 4 6  -2 -2 6 6 -3 -3 0 8 7 0 8 7 -4 -4 7 2 7 2 2  7 7 9 9 4 3 4 3 1 2 5 für i = 3 Wir betrachten die vom Quellknoten 0 über 2 Zwischenorte ausgehende Kanten w(0, 3),w(3, 2),w(2,1) d[1] = d[2] + w(2,1)= 4+(-2)=2 2 4 -2 6 -3 0 8 7 -4 7 2 2 7 9 4 3

24. Beispiel (Bellman-Ford-Algorithmus für negative Gewichte) 1 2 1 2 5 5 6 4 6  -2 -2 6 6 -3 -3 0 8 7 0 8 7 -4 -4 7 2 7 2 2  7 7 9 9 4 3 4 3 1 2 1 2 für i = 4 Wir betrachten die vom Quellknoten 0 über 3 Zwieschenorte ausgehende Kanten w(0, 3),w(3, 2),w(2,1),w(1,4) d[4] = d[1] + w(1,4)= 2+(-4)= - 2 5 5 2 2 4 4 -2 -2 6 6 -3 -3 0 0 8 7 8 7 -4 -4 7 2 7 2 2 -2 7 7 9 9 4 4 3 3

25. Beispiel (Bellman-Ford-Algorithmus für negative Gewichte) 1 2 1 2 5 5 6 4 6  -2 -2 6 6 -3 -3 0 8 7 0 8 7 -4 -4 7 2 7 2 2  7 7 9 9 4 3 4 3 1 2 1 2 Nach der Relaxation haben wir keine vom Quellknoten 0 erreichbare Zyklen negativer Länge 5 5 2 2 4 4 -2 -2 6 6 -3 -3 0 0 8 7 8 7 -4 -4 7 2 7 2 2 -2 7 7 9 9 4 4 3 3

26. Komplexität des Ford-Algorithmus • Die Initialisierung besteht aus Q (|V|) Schritten • Die innere for-Schleife besteht aus der Relaxationsoperation (O(1)) und wird jeweils |E|mal ausgeführt, d.h. ihr Aufwand beträgt O(|E|) • Die äußere for-Schleife wird |V |- 1 mal ausgeführt, jeweils mit einem Aufwand von O(|E| ) , d.h. die geschachtelte for-Schleife ist mit O(|V|*|E|) zu kalkulieren • Die nachfolgende Prüfung auf Existenz negativer Zyklen kostet O(|E|) • Die Gesamtkomplexität des Ford-Algorithmus beträgt daher O(|V|*|E|) .

27. Das n : n – KW - Problem (all - pairs shortest paths) • Kürzeste Wege zwischen allen Knoten des Graphen erhält man, indem man für jeden Knoten das 1 : n - Problem löst, d.h.den Dijkstra - oder den Ford-Algorithmus |V| mal aufruft. • Dies führt zu einer Gesamtkomplexität von O((|V|2*E ) (Ford-Algorithmus) bzw. O(|V|*|E|log|V|) (Dijkstra-Algorithmus) • Bei dünn vermaschten Graphen, z.B. wenn |E| = O (|V|), und nichtnegativen Gewichten ist diese Vorgehensweise zu empfehlen und der Dijkstra-Algorithmus einzusetzen. • In anderen Fällen gibt es spezielle Algorithmen für das n : n – KW - Problem

28. Johnson‘s Algorithmus • Der KW – Algorithmus nach Johnson ist ein APSP-Algorithmus. Er benutzt Dijkstra und Bellman-Ford Algorithmen als Hilfsalgorithmen und führt eine Rekalibrierung durch. • Es wird zuerst mit Bellman-Ford die Existenz negativer Zyklen geprüft • Dann wird in zweitem Schritt, falls wir keinen negativen Zyklus haben, rekalibriert, so bekommen wir einen Graph, dessen Kanten positiv sind . • Weiter können wir Dijkstra den kürzesten Weg für alle Knoten berechnen

29. Bestimmung der Rekalibrierung : Füge einen zusätzlichen Knoten s zum Graph hinzu und verbinde diesen Knoten s mit jedem anderen Knoten v  V [G] durch eine Kante der Länge 0. Berechne alle h(v) und benutze dabei Bellman-Ford Algorithmus (h(v)=(s,v) ) . Dann kann man w(u,v) –Werte nach der Formel w(u,v) = w(u,v) + h(u) - h(v) bekommen w : E  R 0 b s 0 v 0 u Graph

30. Rekalibrierung • h : VR heißt eine Rekalibrierung einen gerichteten Graphen G = (V , E) • mit Gewichtsfunktion w : V R, falls (u,v)  E : h(u) + w(u,v)  h(v) gilt . • Beobachtung. • Ist h eine Rekalibrierung , so ist w : E R • mit (u,v)  E : w(u,v) : = w(u,v) + h(u) – h(v) eine nicht negativeGewichtsfunktion. • Für w gilt zusätzlich : Ist p = (v0 ,..., vn) ein Weg, so ist • w(p)= k w(vi, vi+1) =  k (w(vi, vi+1) + h(vi) - h(vi+1) ) • i=1 i=1 • =  n w(vi, vi+1) + h(v1) - h(vn) = w(p) + h(v1) - h(vn) qed. • i=1 • Falls p ein Kreis ist: • n w(vi, vi+1) =  n (w(vi, vi+1) ) i=1 i=1

31. JOHNSON(G) 1 compute G , where V [G ] = V [G] {s}and E[G'] = E[G] {(s , v) : v V [G]}, and w(s , v) = 0 for all v  V [G] 2 if BELLMAN-FORD(G , w, s) = FALSE 3 then print “ Eingangsgraph hat einen negativen Zyklus” 4 else for each vertex v  V [G] 5 do set h(v) to (s, v) computed by BELLMAN-FORD 6 for each edge (u, v) E[G ] 7 do w(u, v)  w(u, v) + h(u) − h(v) 8 for each vertex u  V [G] 9 do run DIJKSTRA(G, w , u) to compute (u, v) for all v  V [G] 10 for each vertex v  V [G] 11 do duv(u, v) + h(v) − h(u) 12 return D

32. Beispiel (Johnson -Algorithmus für negative Gewichte) B A C E D

33. Beispiel (Johnson -Algorithmus für negative Gewichte) B A C E D

34. Beispiel (Johnson - Algorithmus für negative Gewichte) B A C E D

35. Beispiel (Johnson -Algorithmus für negative Gewichte) B d(B) = (A, B) = 2 d(C) = (A, C) = 2 d(D) = (A, D) = 2 d(E) = (A, E) = 0 -1 0 4 A 10 C 0 -5 13 2 0 0 0 -4 0 2 D E d(B) = (A, B) + h(B) − h(A) = 1 d(C) = (A, C) + h(C) − h(A) = - 3 d(D) = (A, D) + h(D) − h(A) = 2 d(E) = (A, E) + h(E) − h(A) = - 4

36. Beispiel (Johnson -Algorithmus für negative Gewichte) B d(A) = (B, A) = 2 d(C) = (B, C) = 0 d(D) = (B,D) = 0 d(E) = (B, E) = 2 -1 0 4 A 10 C 0 -5 13 0 2 0 0 d(A) = (B, A) + h(A) − h(B) = 3 d(C) = (B, C) + h(C) − h(B)= -4 d(D) = (B, D) + h(D)− h(B) = 1 d(E) = (B, E) + h(E) − h(B)= -1 -4 0 2 D E

37. Beispiel (Johnson -Algorithmus für negative Gewichte) B d(A) = (C, A) = 2 d(B) = (C, B) = 0 d(D) = (C, D) = 0 d(E) = (C, E) = 2 -1 0 4 A 10 C 0 -5 13 0 2 0 0 d(A) = (C, A) + h(A) − h(C) = 7 d(B) = (C, B) + h(B) − h(C) = 4 d(D) = (C,D) + h(D) − h(C) = 5 d(E) = (C, E) + h(E) − h(C) = 3 -4 0 2 D E

38. Beispiel (Johnson -Algorithmus für negative Gewichte) B d(A) = (D, A) = 2 d(B) = (D, B) = 0 d(C) = (D, C) = 0 d(E) = (D, E) = 2 -1 0 4 A 10 C 0 -5 13 2 0 0 0 d(A) = (D, A) + h(A) − h(D) = 2 d(B) = (D, B) + h(B) − h(D) = -1 d(C) = (D, C) + h(C) − h(D) = -5 d(E) = (D, E) + h(E) − h(D) = -2 -4 0 2 D E

39. Beispiel (Johnson -Algorithmus für negative Gewichte) B d(A) = (E, A) = 4 d(B) = (E, B) = 2 d(C) = (E, C) = 2 d(D) = (E, D) = 2 -1 0 4 A 10 C 0 -5 13 0 2 0 0 d(A) = (E, A) + h(A) − h(E) = 8 d(B) = (E, B) + h(B) − h(E) = 5 d(C) = (E, C) + h(C) − h(E) = 1 d(D) = (E, D) + h(D) − h(E) = 6 -4 0 2 D E

40. Komplexität des Johnson -Algorithmus • Die Initialisierung besteht aus Q (|V|) Schritten • Prüfung auf Existenz negativer Zyklen mit Bellman-Ford-Algorithmus O (|VE|) Schritten • Rekalibrierung Q (|E|) • Dijkstradurchlauf O (|VE|) • Distanzberechnung Q(|V|²) Die Gesamtkomplexität des Johnson-Algorithmus beträgt O (|V|²lg|V| + |V||E|lg|V|)