Kap. 6.6: Kürzeste Wege

Transkript

1 Nachtest für Ausnahmefälle Kap..: Kürzeste Wege Professor Dr. Lehrstuhl für Algorithm Engineering, LS Fakultät für Informatik, TU Dortmund./. VO DAP SS 00./. Juli 00 Di. Juli 00, :00 Uhr, OH, R. 0 Anmeldung bis. Juli erforderlich via an (Nicola Beume ist nicht da) Stoff: Alles bis inkl. Hashing (inkl..-0. Übungsblatt) Teilnahmevoraussetzungen: Attest/Entschuldigt beim. oder. Übungstest oder besondere Härtefälle anerkannt in meiner Sprechstunde Di..0,: Uhr-: Uhr oder via bis..0 Kürzeste Wege - Überblick Single-source-shortest-path (SSSP) All-pair-shortest-paths Algorithmus von Floyd-Warshall Motivation Was gibt es heute Besonderes? Dijkstra oder Wie funktioniert mein Navi? Und wenn mir das zu schwer ist? Einfacher Algorithmus für APSP Kürzeste Wege Achtung: in diesem Abschnitt gerichtete gewichtete Graphen! Kürzeste Wege Problem Gegeben: gerichteter Graph G=(V,A) Gewichtsfunktion w : A R hier: w 0 Keine Mehrfachkanten Gesucht: Der bzgl. Gewicht w kürzeste Weg von Startknoten zu Zielknoten.

2 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 Kürzeste Wege Probleme Single Source Shortest Path (SSSP) Single Destination Shortest Path Single Pair Shortest Path All Pairs Shortest Path (APSP). 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, e k,v k Optimale Substruktur Pfad über v 0 =s, v,, 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 0 Single Source Shortest Path Keine negativen Kreise!! -k Kürzeste Wege von Knoten s bilden immer einen Baum - Spezialfall: w(e) 0 (Strecke, Fahrtzeit)? 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]

3 Idee des Dijkstra-Algorithmus. S := {s} // S Knoten im SPT. d[s] := 0; π[s] := nil // s Wurzel. while A(S) ø do // erreichbare Knoten. // Optimale Substruktur Sei e = (u, v) A(S) mit d[u] + w(e) minimal genauer: s. später:. S := S {v} PQ und edge scanning. d[v] := d[u] + w(e). π[v] := u. end while 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 Korrektheit Induktion über die Kanten e,,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 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- } gefolgt von einer Kante (x, y) A(V i- ). 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 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. 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] s Priority Queue PQ: Knoten, Priorität Weglänge Kandidatenmenge K in PQ: Weg von s gefunden Abgeschlossene Knoten: Minimum aus PQ Vorgänger-Kanten in PQ: π

4 Vorgänger-Kanten in PQ: π Vorgänger-Kanten in PQ: π 0 0 Vorgänger-Kanten in PQ: π 0 0 0

5 Pseudo-Code: Initialisierung G=(V, A), w: A R 0 + () var π[v], PriorityQueue Q, pos[v] () for each u V \ {s} do { () pos[u] := Q.INSERT(, u) () π[u] := nil () } () pos[s] := Q.INSERT(0, s) () π[s] := nil Pseudo-Code () while not Q.ISEMPTY() do { () (d u, u ) := Q.EXTRACTMIN(); // d u Abstand s zu u (0) pos[u] := nil // Minimum entfernt () for all e = (u,v) A - (u) do { // Erreichbare Knoten () if d u +w(e) < Q.PRIORITY(pos[v]) then { () Q.DECREASEPRIORITY(pos[v], d u + w(e)) () π[v] := u () } () } () } 0

6 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 Analyse Aufbau des Heaps in O( V ) V Durchläufe der while-schleife Z. mit EXTRACTMIN O( V log V ) A Aufrufe von DECREASEPRIORITY max. O( A log V ) Gesamtlaufzeit O(( V + A )log V ).. All Pairs Shortest Paths All-Pairs Shortest Paths (APSP) Gegeben: gerichteter Graph G = (V,A) Gewichtsfunktion w : A R 0 + Gesucht: ein kürzester Weg von u nach v für jedes Paar u, v V 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 log V ) jetzt: schnellerer Algorithmus für dichte Graphen Algorithmus von Floyd-Warshall Idee: Löse eingeschränkte Teilprobleme: Sei V k :={v,,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 die Länge eines kürzesten Weges von v i nach v j, der nur Knoten aus V k als Zwischenknoten benutzt Berechnung von d ij Berechnung von d ij : d ij (0) = w(v i,v j } Bereits berechnet: d ij (k-) für alle i,j n Für einen kürzesten Weg von v i nach v j gibt es zwei Möglichkeiten: v i v k V k- v j

7 Berechnung von d ij 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 = d ij (k-) 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- benutzen: d ij = d ik (k-) + d kj (k-) d ij := min (d (k-) ij, d (k-) ik + d (k-) kj ) v i v Für k=n: optimale Wege gefunden j v k V k- v v D (0 ) = v v v v v v v v v v v v v v v v v v v v v v v D (0) = D () = D () = D () = v v v v v v v v v v D () = D () = D () = D () =

8 D () = v v v v v D () = Algorithmus von Floyd-Warshall () for i:= to n do () for j:= to n do () d (0) ij := w(v i,v j } () } } () for k:= to n do () for i:= to n do () for j:= to n do () d ij := min (d ij (k-), d ik (k-) + d kj (k-) ) () } } } Diskussion Ist man auch an den Wegen selbst interessiert, dann: Vorgängermatrix: π ij für jede 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-) < d ik (k-) + d kj (k-) dann: π ij := π ij (k-) sonst: π ij := π kj (k-) Laufzeit-Analyse Speicherplatzverbrauch für d-matrizen: Θ( V ) Man benötigt zur Berechnung von d ij nur die Werte von d ij (k-) Θ( V ) Speicherplatz, genauso für die π-matrizen Laufzeit: Θ( V ) Algorithmus von Floyd-Warshall Der Algorithmus von Floyd-Warshall berechnet das APSP-Problem in einer Laufzeit von Θ( V ) mit einem Speicherverbrauch von Θ( V ). Der Algorithmus von Floyd-Warshall funktioniert auch mit negativen Kantenkosten, solange kein negativer Kreis in G enthalten ist. 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 ) 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 ) Aber: Floyd-Warshall konzeptionell einfacher! Für dünne Graphen: APSP mit Dijkstra schneller! DAP Ende SS0 Graphen 0