Organisatorisches VL-17: Kürzeste Pfade (Datenstrukturen und Algorithmen, SS 2017) Walter Unger Vorlesung: Gerhard Woeginger (Zimmer 4024 im E1) Sprechstunde: Mittwoch 11:15 12:00 Übungen: Tim Hartmann, David Korzeniewski, Björn Tauer Email: dsal-i1@algo.rwth-aachen.de Webseite: http://algo.rwth-aachen.de/lehre/ss17/dsa.php SS 2017, RWTH Nächste Vorlesung: Dienstag, Jul 4, 16:15 17:45 Uhr, Aula 1 DSAL/SS 2017 VL-17: Kürzeste Pfade 1/44 DSAL/SS 2017 VL-17: Kürzeste Pfade 2/44 Das Rechenproblem: Kürzeste Pfade (1) Kürzeste Pfade Single-Source Shortest Path Bellman-Ford Dijkstra All-Pairs Shortest Paths Transitive Hüllen Algorithmus von Warshall Algorithmus von Floyd DSAL/SS 2017 VL-17: Kürzeste Pfade 3/44 DSAL/SS 2017 VL-17: Kürzeste Pfade 4/44
Das Rechenproblem: Kürzeste Pfade (2) Kürzeste Pfade: Das Problem Beispiel (kürzester Weg) Eingabe: 1. Eine Strassenkarte, auf der der Abstand zwischen jedem Paar von benachbarten Kreuzungen eingezeichnet ist, 2. eine Startkreuzung s, 3. eine Zielkreuzung t. Ausgabe: Der kürzeste Weg von s nach t. DSAL/SS 2017 VL-17: Kürzeste Pfade 5/44 DSAL/SS 2017 VL-17: Kürzeste Pfade 6/44 Kürzeste Pfade: Notation Kürzeste Pfade: Varianten Gegeben ist ein kanten-gewichteter Graph G = (V, E, W ). Gewicht eines Pfades = Summe der Gewichte der Kanten Ein kürzester Pfad von Knoten s V zu Knoten v V ist ein Pfad von s nach v mit minimalem Gewicht. Im Folgenden ist δ : (V V ) (R {+inf}) eine Funktion, sodass: δ(s, v) ist das Gewicht des kürzesten Pfades von s nach v, und δ(s, v) = +inf, falls v von s nicht erreichbar ist. Es gibt viele verschiedene Problemvarianten: Kürzeste Pfade von einem Startknoten s zu allen anderen Knoten: Single-Source Shortest Paths (SSSP). Kürzeste Pfade von allen Knoten zu einem Zielknoten t. Lässt sich auf SSSP zurückführen. Kürzester Pfad für ein festes Knotenpaar u, v. Es ist kein Algorithmus bekannt, der asymptotisch schneller ist als der beste SSSP-Algorithmus. Kürzeste Pfade für alle Knotenpaare. All-Pairs Shortest Paths (APSP, zweiter Teil dieser Vorlesung). DSAL/SS 2017 VL-17: Kürzeste Pfade 7/44 DSAL/SS 2017 VL-17: Kürzeste Pfade 8/44
Single-Source Shortest Paths Single-Source Shortest Path Problem (Single-Source Shortest Path) Für einen fixen gegebenen Knoten s V (Quelle/source), bestimme für jeden anderen Knoten t V einen kürzesten Pfad von s zu t. DSAL/SS 2017 VL-17: Kürzeste Pfade 9/44 DSAL/SS 2017 VL-17: Kürzeste Pfade 10/44 Der Bellman-Ford Algorithmus Bellman-Ford Berechnet kürzeste Pfade von einem einzigen Startknoten aus Erlaubt negative Kantengewichte. Zeigt an, ob es einen Kreis mit negativem Gewicht gibt, der vom Startknoten aus erreichbar ist. Falls ein solcher Kreis gefunden wird, gibt es keine Lösung (da die Gewichte der kürzesten Pfade nicht mehr wohldefiniert sind). Sonst verbessert der Algorithmus iterativ für jeden Knoten v eine obere Grenze dist[v] für δ(s, v), bis das Minimum gefunden wird. Kürzeste Pfade können nach Terminierung mittels der im Array prev gespeicherten Vorgängerknoten entlang eines kürzesten Pfades rekonstruiert werden. DSAL/SS 2017 VL-17: Kürzeste Pfade 11/44 DSAL/SS 2017 VL-17: Kürzeste Pfade 12/44
Bellman-Ford: Grundideen Initialisierung: dist[v]=+inf; dist[start]=0. Für alle Kanten (v, w) E: Relaxierung: Ist das bisher bekannte Gewicht dist[w] grösser als dist[v]+w(v,w), so verbessere dist[w] auf diesen Wert. Wiederhole den vorigen Schritt bis sich nichts mehr ändert, oder brich, falls ein negativer Kreis gefunden wird. Korrektheit von Bellman-Ford Falls nach V 1 Wiederholungen noch Verbesserungen möglich sind, so gibt es einen negativen Kreis. Andernfalls gilt dist[v] = δ(s, v) für alle Knoten v V. Beweisidee: Pfad ohne Kreis in (V, E, W ) enthält V 1 Zwischenknoten. Bellman-Ford in Pseudo-Code 1 bool bellmanford(list adj[n], int n, int start, 2 int &dist[n], int &prev[n]) { 3 4 for (int v = 0; v < n; v++) // fuer alle Knoten v 5 dist[v] = +inf; 6 prev[v] = -1; // v hat noch keinen Vorgaenger 7 } 8 9 dist [ start ] = 0; // Entfernung von start zu start ist 0 10 for ( int i = 1; i < n; i ++) // n -1 Durchlaeufe 11 for ( int v = 0; v < n; v ++) // fuer alle Knoten v 12 foreach ( edge in adj [ v]) 13 if ( dist [ edge. target ] > dist [v] + edge. weight ) { 14 dist [ edge. target ] = dist [v] + edge. weight ; 15 prev [ edge. target ] = v; 16 } // Relaxierung 17 18 for (int v = 0; v < n; v++) // fuer alle Knoten v 19 foreach (edge in adj[v]) 20 if (dist[edge.target] > dist[v] + edge.weight) 21 return false; // Kreis mit negativem Gewicht 22 return true ; 23 } Zeitkomplexität: O( V E ) DSAL/SS 2017 VL-17: Kürzeste Pfade 13/44 DSAL/SS 2017 VL-17: Kürzeste Pfade 14/44 Bellman-Ford: Beispiel 0 14 14 4 9 18 6 3 10 2-12 Dijkstra 6 3 24 8 15 DSAL/SS 2017 VL-17: Kürzeste Pfade 15/44 DSAL/SS 2017 VL-17: Kürzeste Pfade 16/44
Der Dijkstra Algorithmus Grundlegende Annahme Alle Kantengewichte sind nicht-negativ: W (u, v) 0 für alle (u, v) E. Ergo: Kürzeste Pfade enthalten keine Kreise Edsger Wybe Dijkstra (1930-2002), Turing Award 1972 Dijkstra: Grundideen Wie beim Algorithmus von Prim klassifizieren wir die Knoten in drei Kategorien: Baumknoten: gehören zum bis jetzt konstruierten Baum Randknoten: nicht im Baum, aber adjazent zu Knoten im Baum Ungesehene Knoten: alle anderen Knoten. Grundkonzept: Kein Knoten ausserhalb des Baumes hat einen kürzeren Pfad als die Knoten im Baum. Jedem Knoten v ist ein Wert dist[v] zugeordnet: Für Baumknoten v gilt: dist[v] = δ(s, v); Für Randknoten v gilt: dist[v] ist Minimum der Gewichte aller Pfade vom Startknoten zu v, wobei die letzte Kante im Schnitt liegt; Für ungesehenen Knoten v gilt: dist[v] =+inf. DSAL/SS 2017 VL-17: Kürzeste Pfade 17/44 DSAL/SS 2017 VL-17: Kürzeste Pfade 18/44 Dijkstra Algorithmus: Grundgerüst Dijkstra Algorithmus: Beispiel 1 // ungerichteter Graph G mit n Knoten 2 void dijkstrasp ( Graph G, int n) { 3 initialisiere alle Knoten als UNGESEHEN ( WHITE ); 4 markiere s als BAUM (BLACK) und setze d(s, s) = 0; 5 reklassifiziere alle zu s adj Knoten als RAND ( GRAY ); 6 while ( es gibt Randknoten ) { 7 waehle von allen Kanten zwischen Baumknoten t und 8 Randknoten v mit minimalem d(s, t) + W (t, v); 9 reklassifiziere v als BAUM ( BLACK ); 10 fuege Kante (t, v) zum Baum hinzu ; 11 setze d(s, v) = d(s, t) + W (t, v); 12 reklassifiziere alle zu v adj UNGESEHENen Knoten 13 als RAND ( GRAY ); 14 } 15 } Die Unterschiede zu Prim s Spannbaum Algorithmus sind rot gekennzeichnet 0 14 14 6 10 3 6 5 10 8 4 2 5 14 7 9 15 DSAL/SS 2017 VL-17: Kürzeste Pfade 19/44 DSAL/SS 2017 VL-17: Kürzeste Pfade 20/44
Dijkstra Algorithmus: Korrektheit (1) Dijkstra Algorithmus: Korrektheit (2) Theorem Wir betrachten einen Zeitpunkt während der Exekution des Dijkstra Algorithmus. Es sei B der zu diesem Zeitpunkt konstruierte (rote) Teilbaum. Dann gilt: 1. dist[v] δ(s, v) für alle Knoten v V 2. dist[v] = δ(s, v) für alle Baumknoten v B 3. dist[v] = min({ } {δ(s, x) + W (x, v) x B und (x, v) E}) für alle Nicht-Baumknoten v V \ B; 4. δ(s, v) δ(s, u) für alle Baumknoten v B und u V \ B. 1. dist[v] δ(s, v) für alle Knoten v V 2. dist[v] = δ(s, v) für alle Baumknoten v B 3. dist[v] = min({ } {δ(s, x) + W (x, v) x B, (x, v) E}) für v V \ B 4. δ(s, v) δ(s, u) für alle Baumknoten v B und u V \ B Beweis. 1. und 3. und 4. sind (ziemlich) trivial. Wir beweisen 2. durch Induktion über die Anzahl der Baumknoten: Basis: B ist leer und B = {s} (nach erster Iteration): trivial. Ind. Schritt: Nimm an, Behauptung gilt für B = k > 0. Sei v der Knoten der als nächster zum Baum B hinzugefügt wird. Der Fall dist[v] = +inf ist trivial. Betrachte dist[v] +inf. Dann gibt es eine Kante vom Baumknoten x = prev[v] B zu v B. Aus 3. folgt, dass dist[v] das Gewicht des kürzesten Pfades von s nach v über Baumknoten ist. Aus 4. und der Wahl von v folgt, dass es keinen kürzeren Pfad gibt, d.h., dist[v] = δ(s, v). DSAL/SS 2017 VL-17: Kürzeste Pfade 21/44 DSAL/SS 2017 VL-17: Kürzeste Pfade 22/44 Korrektheit Dijkstra Algorithmus: Implementierung Theorem (Korrektheit) Der Dijkstra Algorithmus berechnet die kürzesten Abstände zwischen Knoten s und jedem von s aus erreichbaren Knoten in G. 1 // Input : gewichteter Graph mit n Knoten, Startknoten 2 void dijkstra(int adj[n], int n, int start, int &dist[n], 3 int &prev[n]) { 4 for (int i = 0; i < n; i++) { 5 dist[i] = inf; prev[i] = -1; 6 } 7 dist[start] = 0; // start ist Randknoten mit Kosten 0 8 Q = 0,...,n-1; // Q enthaelt alle ungesehenen Knoten 9 // und alle Randknoten 10 while ( Q not empty ) { 11 // verschiebe billigsten Randknoten v in Baum : 12 // extractmin ( Q) bestimmt Element e aus Q mit minimalem 13 // dist [ e], entfernt e aus Q und gibt e zurueck 14 v = extractmin ( Q); 15 for each ( edge in adj [ v]) // aktualisiere Kosten 16 // fuer Randknoten 17 if ( edge. target in Q and 18 dist [v]+ edge. weight < dist [ edge. target ]) { 19 dist [ edge. target ] = dist [v] + edge. weight ; 20 prev [ edge. target ] = v; 21 } 22 } 23 } DSAL/SS 2017 VL-17: Kürzeste Pfade 23/44 DSAL/SS 2017 VL-17: Kürzeste Pfade 24/44
Dijkstra Algorithmus: Anmerkungen Die kürzesten Wege werden mit zunehmendem Abstand zur Quelle s gefunden. Implementierung: Ähnlich zum Spannbaum Algorithmus von Prim. Zeitkomplexität im Worst-Case: Θ( V 2 ). Untere Schranke der Komplexität: Ω( E ) (Im schlimmsten Fall müssen alle Kanten überprüft werden.) Platzkomplexität: O( V ). All-Pairs Shortest Paths Dijkstra erlaubt keine negative Kosten. Warum? DSAL/SS 2017 VL-17: Kürzeste Pfade 25/44 DSAL/SS 2017 VL-17: Kürzeste Pfade 26/44 All-Pairs Shortest Paths Binäre Relationen Wir betrachten gewichtete gerichtete Graphen G = (V, E, W ). Negative Gewichte sind erlaubt, aber keine Kreise mit negativem Gewicht. Nicht vorhandene Kanten haben Gewicht W (, ) = +inf. Problem (All-Pairs Shortest Path) Berechne für jedes Paar i, j das Gewicht D[i,j] des kürzesten Pfades. Naive Lösung: Wende SSSP-Algorithmus (z.b. Bellman-Ford) V mal an. Dies führt zu Worst-Case Zeitkomplexität O( V 4 ). Effizientere Version: Floyd s Algorithmus Binäre Relation Eine (binäre) Relation R über einer Menge S ist eine Teilmenge R S S = S 2. Reflexivität, Transitivität Eine Relation R ist reflexiv, wenn (u, u) R für alle u S transitiv, wenn aus (u, v) R und (v, w) R immer (u, w) R folgt Transitive Hülle Die transitive Hülle R einer Relation R ist die kleinste Erweiterung (Obermenge) R R S 2, sodass R reflexiv und transitiv ist. Transitive Hülle eines Graphen Für Graphen mit Menge S = V und Relation R = E gilt: (u, v) R gdw. es gibt Pfad von u nach v. DSAL/SS 2017 VL-17: Kürzeste Pfade 27/44 DSAL/SS 2017 VL-17: Kürzeste Pfade 28/44
Transitive Hülle: Beispiel R = 0 1 0 0 1 0 0 0 1 0 0 1 0 0 0 0 0 1 0 0 0 0 0 1 0 und transitive Hülle R = 1 1 1 1 1 0 1 1 1 0 0 1 1 1 0 0 1 1 1 0 0 1 1 1 1 A B A B Algorithmus von Warshall E C E C D D Binäre Relation R Transitive Hülle R DSAL/SS 2017 VL-17: Kürzeste Pfade 29/44 DSAL/SS 2017 VL-17: Kürzeste Pfade 30/44 Algorithmus von Warshall: Idee (1) Aus R[i,k] und R[k,j] folgt Erreichbarkeit R[i,j]. Algorithmus von Warshall: Idee (2) Das reicht bereits aus, um längere Pfade zu berücksichtigen: i j k 1 2 Die Reihenfolge spielt dabei keine Rolle: 1 foreach (k V ) 2 foreach ( eingehende Kante (i, k) E ) 3 foreach ( ausgehende Kante (k, j) E ) 4 Fuege (i, j) zu E hinzu. 2 1 DSAL/SS 2017 VL-17: Kürzeste Pfade 31/44 DSAL/SS 2017 VL-17: Kürzeste Pfade 32/44
Algorithmus von Warshall: Idee (3) Algorithmus von Warshall: Idee (4) Allgemeiner Fall: i {1,..., k 1} k {1,..., k 1} Das lässt sich als Rekursionsgleichung schreiben, wobei t (k) ij = true besagt, dass nach Berücksichtigung der Zwischenknoten {1,..., k} der Knoten j von i aus erreichbar ist: t (k) ij = t (k 1) ij ( t (k 1) t (k 1) ) j t (k) ij = false true t (k 1) ij ( t (k 1) Da zur Berechnung von t (k) ij ) t (k 1) für k = 0, falls (i, j) E für k = 0, falls (i, j) E für k > 0 nur die Werte t (k 1) uv gebraucht werden und da keine älteren Werte t uv (j) mit j < k 1 gebraucht werden, kann die Berechnung direkt im Ausgabearray (in-place) erfolgen. DSAL/SS 2017 VL-17: Kürzeste Pfade 33/44 DSAL/SS 2017 VL-17: Kürzeste Pfade 34/44 Algorithmus von Warshall: Beispiel (1) Eine mögliche Nummerierung der Knoten: Algorithmus von Warshall: Beispiel (2) Eine andere Nummerierung der Knoten: 2 4 0 1 4 6 5 7 x x x x x x x x x x x x x x x x x x x x 0 1 5 2 6 3 x x x x x x x x x x x x x x x x x x x x x x x x 3 7 Permutierung der Knoten liefert gleiche Matrixdarstellung von R wie zuvor DSAL/SS 2017 VL-17: Kürzeste Pfade 35/44 DSAL/SS 2017 VL-17: Kürzeste Pfade 36/44
1 foreach (k V ) 2 foreach ( eingehende Kante (i, k) E ) 3 foreach ( ausgehende Kante (k, j) E ) 4 Fuege (i, j) zu E hinzu. 1 void transclos ( bool A[ n][ n], int n, bool & R[ n][ n]) { 2 for ( int i = 0; i < n; i ++) 3 for ( int j = 0; j < n; j ++) 4 R[i, j] = A[i, j]; // Kopiere A nach R 5 6 for ( int i = 0; i < n; i ++) 7 R[i, i] = true ; // reflexive Huelle 8 9 for ( int k = 0; k < n; k ++) 10 for ( int i = 0; i < n; i ++) 11 for ( int j = 0; j < n; j ++) 12 R[i, j] = R[i, j] ( R[i, k] && R[k, j]); 13 } Algorithmus von Floyd Zeitkomplexität: Θ( V 3 ); Platzkomplexität: Θ( V 2 ) DSAL/SS 2017 VL-17: Kürzeste Pfade 37/44 DSAL/SS 2017 VL-17: Kürzeste Pfade 38/44 Der Algorithmus von Floyd Der Algorithmus von Floyd: Idee 36 i 25 10 j Zurück zu All-Pairs Shortest Paths: Algorithmus von Floyd löst APSP Grundidee: Erweiterung von Algorithmus von Warshall (Literatur nennt den Algorithmus oft Floyd-Warshall ) {1,..., k 1} k {1,..., k 1} Wir gehen wie bei Warshall vor, jedoch mit der folgenden angepassten Rekursionsgleichung: W (i, j) für k = 0 d (k) ij = ( ) min d (k 1) ij, d (k 1) + d (k 1) für k > 0 ( ) statt: t (k) ij = t (k 1) ij t (k 1) t (k 1) DSAL/SS 2017 VL-17: Kürzeste Pfade 39/44 DSAL/SS 2017 VL-17: Kürzeste Pfade 40/44
Der Algorithmus von Floyd: Idee Der Algorithmus von Floyd: Beispiel 35 i 25 10 j {1,..., k 1} k {1,..., k 1} https://www.cs.usfca.edu/~galles/visualization/floyd.html Wir gehen wie bei Warshall vor, jedoch mit der folgenden angepassten Rekursionsgleichung: W (i, j) für k = 0 d (k) ij = ( ) min d (k 1) ij, d (k 1) + d (k 1) für k > 0 ( ) statt: t (k) ij = t (k 1) ij t (k 1) t (k 1) DSAL/SS 2017 VL-17: Kürzeste Pfade 40/44 DSAL/SS 2017 VL-17: Kürzeste Pfade 41/44 Der Algorithmus von Floyd: Implementierung Der Algorithmus von Floyd: Erweiterung 1 void floydsp ( double W[ n][ n], int n, double & D[ n][ n]) { 2 for ( int i = 0; i < n; i ++) 3 for ( int j = 0; j < n; j ++) 4 D[i, j] = W[i, j]; // Kopiere W nach D 5 6 for ( int i = 0; i < n; i ++) // reflexive Huelle 7 D[i, i] = 0; 8 9 for ( int k = 0; k < n; k ++) 10 for ( int i = 0; i < n; i ++) 11 for ( int j = 0; j < n; j ++) 12 D[i,j] = min (D[i,j], D[i,k] + D[k,j]); 13 } Zeitkomplexität: Θ( V 3 ); Platzkomplexität: Θ( V 2 ). Hier nicht behandelt: Der Algorithmus kann auch mit negativen Kreisen umgehen. Der angegebene Algorithmus berechnet nur die Länge der Pfade. Der Algorithmus lässt sich leicht auf die Berechung von Pfaden erweitern (z. B. Routingtabellen). Dazu speichern wir für jedes Paar (i, j) jeweils den letzten Zwischenknoten π ij des kürzesten Pfades von i nach j (das heisst, π ij ist der Vorgänger von j auf diesem Pfad). π (k) ij = i null π (k 1) π (k 1) ij für k = 0, i j, falls W (i, j) +inf für k = 0, sonst für k > 0, falls d (k 1) ij sonst > d (k 1) + d (k 1) DSAL/SS 2017 VL-17: Kürzeste Pfade 42/44 DSAL/SS 2017 VL-17: Kürzeste Pfade 43/44
Organisatorisches Nächste Vorlesung: Dienstag, Jul 4, 16:15 17:45 Uhr, Aula 1 Webseite: http://algo.rwth-aachen.de/lehre/ss17/dsa.php DSAL/SS 2017 VL-17: Kürzeste Pfade 44/44