Kap. 6.6: Kürzeste Wege

Transkript

1 Kap. 6.6: Kürzeste Wege Professor Dr. Lehrstuhl für Algorithm Engineering, LS11 Fakultät für Informatik, TU Dortmund 1./. VO DAP SS 009./9. Juli 009 1

2 Nachtest für Ausnahmefälle Di 1. Juli 009, 16:00 Uhr, OH1, R. 0 Anmeldung bis 9. Juli erforderlich via an (Nicola Beume ist nicht da) Stoff: Alles bis inkl. Hashing (inkl Übungsblatt) Teilnahmevoraussetzungen: Attest/Entschuldigt beim 1. oder. Übungstest oder besondere Härtefälle anerkannt in meiner Sprechstunde Di..09,1:1 Uhr-1:1 Uhr oder via bis 9..09

3 Kürzeste Wege - Überblick Single-source-shortest-path (SSSP) Algorithmus von Dijkstra All-pair-shortest-paths Algorithmus von Floyd-Warshall 3

4 Motivation Was gibt es heute Besonderes? Dijkstra oder Wie funktioniert mein Navi? Und wenn mir das zu schwer ist? Einfacher Algorithmus für APSP

5 Kürzeste Wege Achtung: in diesem Abschnitt gerichtete gewichtete Graphen! Kürzeste Wege Problem Gegeben: gerichteter Graph G=(V,A) Gesucht: Gewichtsfunktion w : A R Keine Mehrfachkanten hier: w 0 Der bzgl. Gewicht w kürzeste Weg von Startknoten zu Zielknoten.

6 6

7 Anwendungen Direkte und indirekte (Teilproblem) Anwendungen: Routenplaner (Streckenlänge) Auskunftssysteme für Bus und Bahn (Zeit) Berechnung minimaler Flüsse in Netzwerken DNA Sequenz Analyse

8 Kürzeste Wege Probleme Single Source Shortest Path (SSSP) Single Destination Shortest Path Single Pair Shortest Path All Pairs Shortest Path (APSP) 8

9 6.1 Single Source Shortest Path (SSSP) Bekannt: BFS für ungewichtete kürzeste Wege (USSSP) Jetzt: Kürzeste Wege mit Kantengewichten: Gerichteter Graph G = (V, A) Kantengewichte w(e) R (Strecke, Fahrtzeit) Startknoten s Weglänge w(p) := für p=v 0,e 1, e k,v k 9

10 Optimale Substruktur Pfad über v 0 =s, v 1,, v k kürzester Weg von s nach v k Teilweg v h v j kürzester Weg von v h nach v j v 0 vh v j v k 10

11 Single Source Shortest Path Keine negativen Kreise!! -k? - Kürzeste Wege von Knoten s bilden immer einen Baum Spezialfall: w(e) 0 (Strecke, Fahrtzeit) 11

12 Algorithmus von Dijkstra Analogien mit BFS und Prim: BFS/Prim läßt einzelnen Baum wachsen: Neue Kante verbindet Baum mit Rest Dijkstra bildet Kürzeste-Wege Baum (SPT) ausgehend von Wurzel s, aber andere Auswahl Greedy, ADS: Priority Queue Bezeichnungen Vorgänger von Knoten v im SPT: π[v] Kanten, die Knotenmenge S verlassen: A(S) Min. Abstand vom Startknoten zu Knoten v: d[v] 1

13 Idee des Dijkstra-Algorithmus 1. S := {s} // S Knoten im SPT. d[s] := 0; π[s] := nil // s Wurzel 3. while A(S) ø do // erreichbare Knoten. // Optimale Substruktur Sei e = (u, v) A(S) mit d[u] + w(e) minimal. S := S {v} 6. d[v] := d[u] + w(e). π[v] := u 8. end while genauer: s. später: PQ und edge scanning 13

14 Korrektheit Knoten ausserhalb von S sind nur über Knoten bzw. Pfade in S erreichbar Dijkstra wählt Minimum der Weglänge aus S hinaus und erweitert S w nicht-negativ: Spätere Weglängen können nur größer sein als Minimum! Optimale Substruktur: Kürzester Weg besteht aus kürzestem Weg plus Kante 1

15 Korrektheit Induktion über die Kanten e 1,,e n, die der Algorithmus für v wählt, e i = (u i,v i ), v 0 := s. Zeige: v 0,,v i ist kürzester Weg von v 0 nach v i i=0: Keine Kante, korrekt 1 i n: Annahme v 0,,v j kürzester Weg für j<i. Dijkstra wählt Weg mit Kosten d[u i ]+w(e i ). Jeder andere Weg v 0 v i beginnt mit Knoten aus der Menge V i := {v 0,,v i-1 } gefolgt von einer Kante (x, y) A(V i-1 ). Alleine das Wegstück von v 0 nach y hat aber bereits mindestens Kosten d[u i ]+w(e i ), da e i als Minimum gewählt wurde. Alle erreichbaren Knoten werden auch erreicht

16 Realisierung von Dijkstra Knotenmenge S: Kürzester Weg mit Länge d[v] bereits ermittelt Knotenmenge V \ S: Speichere die Knoten mit der Priorität vorläufige Werte für den Abstand zu s (obere Schranke δ(v) d[v]) in Priority Queue, und aktualisiere die Priorität, falls ein günstigerer Weg gefunden wird, δ(s) = 0 1. Wähle mit EXTRACTMIN Knoten u mit minimalem Abstandswert δ(u). Damit gilt d(u)=δ(u). Start: δ(s) = d[s] = 0. Aktualisiere für ausgehende Kanten (u, v) Abstandswerte der Endknoten δ(v) (edge scanning, relaxieren) mit DECREASEPRIORITY und Vorgänger π[v] 16

17 Algorithmus von Dijkstra s Priority Queue PQ: Knoten, Priorität Weglänge Kandidatenmenge K in PQ: Weg von s gefunden Abgeschlossene Knoten: Minimum aus PQ 1

18 Algorithmus von Dijkstra s Ausgehende Kanten des gewählten Knoten Erreichte Kandidaten Vorgänger-Kanten in PQ: π 19

19 Algorithmus von Dijkstra s Ausgehende Kanten des gewählten Knoten Erreichte Kandidaten Vorgänger-Kanten in PQ: π 0

20 Algorithmus von Dijkstra s Ausgehende Kanten des gewählten Knoten Erreichte Kandidaten Vorgänger-Kanten in PQ: π 1

21 Algorithmus von Dijkstra s Ausgehende Kanten des gewählten Knoten Erreichte Kandidaten Vorgänger-Kanten in PQ: π

22 Algorithmus von Dijkstra s Ausgehende Kanten des gewählten Knoten Erreichte Kandidaten Vorgänger-Kanten: π 3

23 Algorithmus von Dijkstra s Ausgehende Kanten des gewählten Knoten Erreichte Kandidaten Vorgänger-Kanten: π

24 Algorithmus von Dijkstra s Ausgehende Kanten des gewählten Knoten Erreichte Kandidaten Vorgänger-Kanten: π

25 Algorithmus von Dijkstra s Ausgehende Kanten des gewählten Knoten Erreichte Kandidaten Vorgänger-Kanten: π 6

26 Algorithmus von Dijkstra s Ausgehende Kanten des gewählten Knoten Erreichte Kandidaten Vorgänger-Kanten: π

27 Algorithmus von Dijkstra s Ausgehende Kanten des gewählten Knoten Erreichte Kandidaten Vorgänger-Kanten: π 8

28 Algorithmus von Dijkstra s Ausgehende Kanten des gewählten Knoten Erreichte Kandidaten Vorgänger-Kanten: π 9

29 Pseudo-Code: Initialisierung G=(V, A), w: A R 0 + (1) var π[v], PriorityQueue Q, pos[v] () for each u V \ {s} do { (3) pos[u] := Q.INSERT(, u) () π[u] := nil () } (6) pos[s] := Q.INSERT(0, s) () π[s] := nil 30

30 Pseudo-Code (8) while not Q.ISEMPTY() do { (9) (d u, u ) := Q.EXTRACTMIN(); // d u Abstand s zu u (10) pos[u] := nil // Minimum entfernt (11) for all e = (u,v) A - (u) do { // Erreichbare Knoten (1) if d u +w(e) < Q.PRIORITY(pos[v]) then { (13) Q.DECREASEPRIORITY(pos[v], d u + w(e)) (1) π[v] := u (1) } (16) } (1) } 31

31 Analyse Laufzeit abhängig von Datenstruktur: Kosten der ExtractMin und vor allem der DecreasePriority Operationen Wir betrachten Binary Heaps Spezielle PQ mit amortisiert konstanter DecreasePriority Zeit: Fibonacci-Heaps 3

32 Analyse Aufbau des Heaps in O( V ) V Durchläufe der while-schleife Z. 8 mit EXTRACTMIN O( V log V ) A Aufrufe von DECREASEPRIORITY max. O( A log V ) Gesamtlaufzeit O(( V + A )log V ) 3

33 6.6. All Pairs Shortest Paths All-Pairs Shortest Paths (APSP) Gegeben: gerichteter Graph G = (V,A) Gesucht: Gewichtsfunktion w : A R 0 + ein kürzester Weg von u nach v für jedes Paar u, v V 3

34 Algorithmen für APSP Idee: Aufruf von Dijkstra für alle Knoten v V Laufzeit: O( V ( V + E ) log V ) für dünne Graphen: O( V log V ) für dichte Graphen: O( V 3 log V ) jetzt: schnellerer Algorithmus für dichte Graphen 36

35 Algorithmus von Floyd-Warshall Idee: Löse eingeschränkte Teilprobleme: Sei V k :={v 1,,v k } die Menge der ersten k Knoten Finde kürzeste Wege, die nur Knoten aus V k als Zwischenknoten benutzen dürfen Zwischenknoten sind alle Knoten eines Weges außer die beiden Endknoten Sei d ij (k) die Länge eines kürzesten Weges von v i nach v j, der nur Knoten aus V k als Zwischenknoten benutzt 3

36 Berechnung von d ij (k) Berechnung von d ij (k) : d ij (0) = w(v i,v j } Bereits berechnet: d ij (k-1) für alle 1 i,j n Für einen kürzesten Weg von v i nach v j gibt es zwei Möglichkeiten: v k v i V k-1 v j

37 Berechnung von d ij (k) Zwei Möglichkeiten für kürzesten Weg von v i nach v j : Der Weg p benutzt v k nicht als Zwischenknoten: dann ist d ij (k) = d ij (k-1) Der Weg p benutzt v k als Zwischenknoten: dann setzt sich p aus einem kürzesten Weg von v i nach v k und einem von v k nach v j zusammen, die jeweils nur Zwischenknoten aus V k-1 benutzen: d ij (k) = d ik (k-1) + d kj (k-1) d ij (k) := min (d ij (k-1), d ik (k-1) + d kj (k-1) ) v i Für k=n: optimale Wege gefunden v k V k-1 v j

38 Beispiel v 1 1 v v 3 3 v 6 v v 1 v v 3 v v v 1 v D (0 ) = v 3 v v

39 Beispiel v 1 1 v v 3 3 v 6 v D (0) = D (1) =

40 Beispiel v 1 1 v v 3 3 v 6 v D (1) = D () =

41 Beispiel v 1 1 v v 3 3 v 6 v D () = D (3) =

42 Beispiel v 1 1 v v 3 3 v 6 v D (3) = D () =

43 Beispiel v 1 1 v v 3 3 v 6 v D () = D () =

44 Algorithmus von Floyd-Warshall (1) for i:=1 to n do () for j:=1 to n do (3) d (0) ij := w(v i,v j } () } } () for k:=1 to n do (6) for i:=1 to n do () for j:=1 to n do (8) d (k) ij := min (d (k-1) ij, d (k-1) ik + d (k-1) kj ) (9) } } } 6

45 Diskussion Ist man auch an den Wegen selbst interessiert, dann: Vorgängermatrix: π ij (k) für jedes 0 k n Initialisierung: Falls i=j oder w(v i,v j )=, dann: π ij (0) := nil Sonst: π ij (0) := i Aktualisierung: Falls d ij (k-1) < d ik (k-1) + d kj (k-1) dann: π ij (k) := π ij (k-1) sonst: π ij (k) := π kj (k-1)

46 Laufzeit-Analyse Speicherplatzverbrauch für d-matrizen: Θ( V 3 ) Man benötigt zur Berechnung von d ij (k) nur die Werte von d ij (k-1) Θ( V ) Speicherplatz, genauso für die π-matrizen Laufzeit: Θ( V 3 ) 8

47 Algorithmus von Floyd-Warshall Der Algorithmus von Floyd-Warshall berechnet das APSP-Problem in einer Laufzeit von Θ( V 3 ) mit einem Speicherverbrauch von Θ( V ). Der Algorithmus von Floyd-Warshall funktioniert auch mit negativen Kantenkosten, solange kein negativer Kreis in G enthalten ist. 9

48 Diskussion Dijkstra-Algorithmus kann durch eine andere Implementierung der Priority-Queue in Laufzeit O( V + E ) realisiert werden Dann: APSP für dichte Graphen: O( V 3 ) Dijkstra-Algorithmus kann durch eine andere Implementierung der Priority-Queue (Fibonacci- Heaps) in Laufzeit O( E + V log V ) realisiert werden (aber eher theoretisch) Dann: APSP für dichte Graphen: O( V 3 ) Aber: Floyd-Warshall konzeptionell einfacher! Für dünne Graphen: APSP mit Dijkstra schneller! Ende Graphen 0