vl-17: kürzeste pfade - rwth aachen universitydienstag,jul4,16:15–17:45uhr,aula1 dsal/ss 2017...

VL-17: Kürzeste Pfade

(Datenstrukturen und Algorithmen, SS 2017)

Walter Unger

SS 2017, RWTH

DSAL/SS 2017 VL-17: Kürzeste Pfade 1/44

Organisatorisches

• Vorlesung: Gerhard Woeginger (Zimmer 4024 im E1)Sprechstunde: Mittwoch 11:15–12:00

• Übungen: Tim Hartmann, David Korzeniewski, Björn TauerEmail: [email protected]

• Webseite: http://algo.rwth-aachen.de/Lehre/SS17/DSA.php

• Nächste Vorlesung:Dienstag, Jul 4, 16:15–17:45 Uhr, Aula 1


Kürzeste Pfade

• Single-Source Shortest Path• Bellman-Ford• Dijkstra

• All-Pairs Shortest Paths• Transitive Hüllen• Algorithmus von Warshall• Algorithmus von Floyd


Das Rechenproblem: Kürzeste Pfade (1)


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 Kreuzungeneingezeichnet ist,

2. eine Startkreuzung s,3. eine Zielkreuzung t.

Ausgabe: Der kürzeste Weg von s nach t.


Kürzeste Pfade: Notation

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:I δ(s, v) ist das Gewicht des kürzesten Pfades von s nach v , undI δ(s, v) = +inf, falls v von s nicht erreichbar ist.


Kürzeste Pfade: Varianten

Es gibt viele verschiedene Problemvarianten:I Kürzeste Pfade von einem Startknoten s zu allen anderen Knoten:

Single-Source Shortest Paths (SSSP).I Kürzeste Pfade von allen Knoten zu einem Zielknoten t.

Lässt sich auf SSSP zurückführen.I Kürzester Pfad für ein festes Knotenpaar u, v .

Es ist kein Algorithmus bekannt, der asymptotisch schneller ist alsder beste SSSP-Algorithmus.

I Kürzeste Pfade für alle Knotenpaare.All-Pairs Shortest Paths (APSP, zweiter Teil dieser Vorlesung).


Single-Source Shortest Path


Single-Source Shortest Paths

Problem (Single-Source Shortest Path)Für einen fixen gegebenen Knoten s ∈ V (Quelle/source),

bestimme für jeden anderen Knoten t ∈ Veinen kürzesten Pfad von s zu t.


Bellman-Ford


Der Bellman-Ford Algorithmus

I Berechnet kürzeste Pfade von einem einzigen Startknoten ausI Erlaubt negative Kantengewichte.I Zeigt an, ob es einen Kreis mit negativem Gewicht gibt, der vom

Startknoten aus erreichbar ist.I Falls ein solcher Kreis gefunden wird, gibt es keine Lösung

(da die Gewichte der kürzesten Pfade nicht mehr wohldefiniert sind).I Sonst verbessert der Algorithmus iterativ für jeden Knoten v eine

obere Grenze dist[v] für δ(s, v), bis das Minimum gefunden wird.I Kürzeste Pfade können nach Terminierung mittels der im Array

prev gespeicherten Vorgängerknoten entlang eines kürzesten Pfadesrekonstruiert werden.


Bellman-Ford: Grundideen

I Initialisierung: dist[v]=+inf; dist[start]=0.I Für alle Kanten (v ,w) ∈ E :

Relaxierung: Ist das bisher bekannte Gewicht dist[w] grösser alsdist[v]+W(v,w), so verbessere dist[w] auf diesen Wert.

I Wiederhole den vorigen Schritt bis sich nichts mehr ändert,oder brich, falls ein negativer Kreis gefunden wird.

Korrektheit von Bellman-FordFalls nach |V |−1 Wiederholungen noch Verbesserungen möglich sind, sogibt 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-Code1 bool bellmanFord(List adj[n], int n, int start,2 int &dist[n], int &prev[n]) 34 for (int v = 0; v < n; v++) // fuer alle Knoten v5 dist[v] = +inf;6 prev[v] = -1; // v hat noch keinen Vorgaenger7 89 dist[ start ] = 0; // Entfernung von start zu start ist 0

10 for (int i = 1; i < n; i++) // n -1 Durchlaeufe11 for (int v = 0; v < n; v++) // fuer alle Knoten v12 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 // Relaxierung1718 for (int v = 0; v < n; v++) // fuer alle Knoten v19 foreach (edge in adj[v])20 if (dist[edge.target] > dist[v] + edge.weight)21 return false; // Kreis mit negativem Gewicht22 return true;23

• Zeitkomplexität: O(|V | · |E |)


Bellman-Ford: Beispiel

0

14

18 ∞

6

24

∞ ∞

14

6

4

10

9

-12

3

38

2

15


Dijkstra


Der Dijkstra Algorithmus

Grundlegende AnnahmeAlle 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 dreiKategorien:

Baumknoten: gehören zum bis jetzt konstruierten BaumRandknoten: nicht im Baum, aber adjazent zu Knoten im BaumUngesehene Knoten: alle anderen Knoten.

Grundkonzept:I Kein Knoten ausserhalb des Baumes hat einen kürzeren Pfad als die

Knoten im Baum.I Jedem Knoten v ist ein Wert dist[v] zugeordnet:I Für Baumknoten v gilt: dist[v] = δ(s, v);I Für Randknoten v gilt: dist[v] ist Minimum der Gewichte aller

Pfade vom Startknoten zu v, wobei die letzte Kante im Schnitt liegt;I Für ungesehenen Knoten v gilt: dist[v] =+inf.


Dijkstra Algorithmus: Grundgerüst

1 // ungerichteter Graph G mit n Knoten2 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 und8 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 Knoten13 als RAND (GRAY);14 15

Die Unterschiede zu Prim’s Spannbaum Algorithmus sind rot gekennzeichnet


Dijkstra Algorithmus: Beispiel

0

14

6

10

7

5 14

∞

14

6

10

55

33

44

88

2

1515

99


Dijkstra Algorithmus: Korrektheit (1)

TheoremWir betrachten einen Zeitpunkt während der Exekution des DijkstraAlgorithmus. Es sei B der zu diesem Zeitpunkt konstruierte (rote)Teilbaum. Dann gilt:1. dist[v] ≥ δ(s, v) für alle Knoten v ∈ V2. dist[v] = δ(s, v) für alle Baumknoten v ∈ B3. 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.


Dijkstra Algorithmus: Korrektheit (2)

1. dist[v] ≥ δ(s, v) für alle Knoten v ∈ V2. dist[v] = δ(s, v) für alle Baumknoten v ∈ B3. dist[v] = min(∞ ∪ δ(s, x) + W (x , v) | x ∈ B, (x , v) ∈ E) für v ∈ V \ B4. δ(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:

I Basis: B ist leer und B = s (nach erster Iteration): trivial.I 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] 6= +inf. Dann gibt es eine Kante vom Baumknotenx = prev[v] ∈ B zu v 6∈ B. Aus 3. folgt, dass dist[v] das Gewicht des kürzestenPfades 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).


Korrektheit

Theorem (Korrektheit)Der Dijkstra Algorithmus berechnet die kürzesten Abstände

zwischen Knoten s und jedem von s aus erreichbaren Knoten in G .


Dijkstra Algorithmus: Implementierung

1 // Input : gewichteter Graph mit n Knoten , Startknoten2 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 08 Q = 0,...,n-1; // Q enthaelt alle ungesehenen Knoten9 // und alle Randknoten

10 while (Q not empty ) 11 // verschiebe billigsten Randknoten v in Baum:12 // extractMin (Q) bestimmt Element e aus Q mit minimalem13 // dist[e], entfernt e aus Q und gibt e zurueck14 v = extractMin (Q);15 for each (edge in adj[v]) // aktualisiere Kosten16 // fuer Randknoten17 if (edge. target in Q and18 dist[v]+ edge. weight < dist[edge. target ]) 19 dist[edge. target ] = dist[v] + edge. weight ;20 prev[edge. target ] = v;21 22 23


Dijkstra Algorithmus: Anmerkungen

I Die kürzesten Wege werden mit zunehmendem Abstand zur Quelle sgefunden.

I Implementierung: Ähnlich zum Spannbaum Algorithmus von Prim.I Zeitkomplexität im Worst-Case: Θ(|V |2).I Untere Schranke der Komplexität: Ω(|E |)

(Im schlimmsten Fall müssen alle Kanten überprüft werden.)I Platzkomplexität: O(|V |).

I Dijkstra erlaubt keine negative Kosten. Warum?


All-Pairs Shortest Paths


All-Pairs Shortest Paths

Wir betrachten gewichtete gerichtete Graphen G = (V ,E ,W ).I Negative Gewichte sind erlaubt, aber keine Kreise mit negativem

Gewicht.I 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 Relationen

Binäre RelationEine (binäre) Relation R über einer Menge S

ist eine Teilmenge R ⊆ S × S = S2.

Reflexivität, TransitivitätEine 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ülleDie transitive Hülle R∗ einer Relation R ist die kleinste Erweiterung(Obermenge) R ⊆ R∗ ⊆ S2, sodass R∗ reflexiv und transitiv ist.

Transitive Hülle eines GraphenFür Graphen mit Menge S = V und Relation R = E gilt:

(u, v) ∈ R∗ gdw. es gibt Pfad von u nach v .


Transitive Hülle: Beispiel

R =

0 1 0 0 10 0 0 1 00 1 0 0 00 0 1 0 00 0 0 1 0

und transitive Hülle R∗ =

1 1 1 1 10 1 1 1 00 1 1 1 00 1 1 1 00 1 1 1 1

D

C

BA

E

Binäre Relation RD

C

BA

E

Transitive Hülle R∗


Algorithmus von Warshall


Algorithmus von Warshall: Idee (1)

Aus R[i,k] und R[k,j] folgt Erreichbarkeit R[i,j].

k

i j

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 .


Algorithmus von Warshall: Idee (2)Das reicht bereits aus, um längere Pfade zu berücksichtigen:

1 2

Die Reihenfolge spielt dabei keine Rolle:

2 1


Algorithmus von Warshall: Idee (3)Allgemeiner Fall:

i j

k

⊆ 1, . . . , k−1 ⊆ 1, . .

. , k−1

Das lässt sich als Rekursionsgleichung schreiben, wobei t(k)ij = true

besagt, dass nach Berücksichtigung der Zwischenknoten 1, . . . , k derKnoten j von i aus erreichbar ist:

t(k)ij = t(k−1)

ij ∨(t(k−1)ik ∧ t(k−1)

kj

)


Algorithmus von Warshall: Idee (4)

t(k)ij =

false für k = 0, falls (i , j) 6∈ Etrue für k = 0, falls (i , j) ∈ E

t(k−1)ij ∨

(t(k−1)ik ∧ t(k−1)

kj

)für k > 0

Da zur Berechnung von t(k)ij nur die Werte t(k−1)

uv gebraucht werdenund da keine älteren Werte t(j)

uv mit j < k−1 gebraucht werden,kann die Berechnung direkt im Ausgabearray (in-place) erfolgen.


Algorithmus von Warshall: Beispiel (1)

Eine mögliche Nummerierung der Knoten:

0

1

2

3

5

4 6

7

x x x x x x · ·· x · x · x · ·· · x · x · · ·· · · x · x · ·· · · · x · x ·· · · · x x · x· · · · · · x ·· · · · · · · x


Algorithmus von Warshall: Beispiel (2)Eine andere Nummerierung der Knoten:

0

1

4

7

6

5 2

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

Permutierung der Knoten liefert gleiche Matrixdarstellung von R∗ wie zuvor


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 R56 for (int i = 0; i < n; i++)7 R[i,i] = true; // reflexive Huelle89 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

Zeitkomplexität: Θ(|V |3); Platzkomplexität: Θ(|V |2)


Algorithmus von Floyd


Der Algorithmus von Floyd

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”)


Der Algorithmus von Floyd: Idee

i j

k

⊆ 1, . . . , k−1 ⊆ 1, . .

. , k−1

25 10

36

Wir gehen wie bei Warshall vor, jedoch mit der folgenden angepasstenRekursionsgleichung:

d (k)ij =

W (i , j) für k = 0

min(d (k−1)

ij , d (k−1)ik + d (k−1)

kj

)für k > 0

statt: t(k)ij = t(k−1)

ij ∨(t(k−1)ik ∧ t(k−1)

kj

)DSAL/SS 2017 VL-17: Kürzeste Pfade 40/44

Der Algorithmus von Floyd: Idee

i j

k

⊆ 1, . . . , k−1 ⊆ 1, . .

. , k−1

25 10

35

Wir gehen wie bei Warshall vor, jedoch mit der folgenden angepasstenRekursionsgleichung:

d (k)ij =

W (i , j) für k = 0

min(d (k−1)

ij , d (k−1)ik + d (k−1)

kj

)für k > 0

statt: t(k)ij = t(k−1)

ij ∨(t(k−1)ik ∧ t(k−1)

kj

)DSAL/SS 2017 VL-17: Kürzeste Pfade 40/44

Der Algorithmus von Floyd: Beispiel

https://www.cs.usfca.edu/~galles/visualization/Floyd.html


Der Algorithmus von Floyd: Implementierung

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 D56 for (int i = 0; i < n; i++) // reflexive Huelle7 D[i,i] = 0;89 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

I Zeitkomplexität: Θ(|V |3); Platzkomplexität: Θ(|V |2).I Hier nicht behandelt: Der Algorithmus kann auch mit negativen

Kreisen umgehen.


Der Algorithmus von Floyd: Erweiterung

I Der angegebene Algorithmus berechnet nur die Länge der Pfade.I Der Algorithmus lässt sich leicht auf die Berechung von Pfaden

erweitern (z. B. Routingtabellen).I 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 für k = 0, i 6= j , falls W (i , j) 6= +inf

null für k = 0, sonst

π(k−1)kj für k > 0, falls d (k−1)

ij > d (k−1)ik + d (k−1)

kj

π(k−1)ij sonst


https://www.cs.usfca.edu/~galles/visualization/Floyd.html

Organisatorisches

• Nächste Vorlesung:Dienstag, Jul 4, 16:15–17:45 Uhr, Aula 1

• Webseite: http://algo.rwth-aachen.de/Lehre/SS17/DSA.php


vl-17: kürzeste pfade - rwth aachen universitydienstag,jul4,16:15–17:45uhr,aula1 dsal/ss 2017...

Documents