25.Juni2018 Vorlesung17:KürzestePfade(K24)Joost-PieterKatoen DatenstrukturenundAlgorithmen

(1)

Kürzeste Pfadalgorithmen

Datenstrukturen und Algorithmen

Vorlesung 17: Kürzeste Pfade (K24)

Joost-Pieter Katoen

Lehrstuhl für Informatik 2 Software Modeling and Verification Group

https://moves.rwth-aachen.de/teaching/ss-18/dsal/

25. Juni 2018

Joost-Pieter Katoen Datenstrukturen und Algorithmen 1/43

(2)

Kürzeste Pfadalgorithmen

Übersicht

1 Kürzeste Pfade

2 Single-Source Shortest Path Bellman-Ford

Dijkstra

3 All-Pairs Shortest Paths Transitive Hülle

Algorithmus von Warshall Der Algorithmus von Floyd

(3)

Kürzeste Pfadalgorithmen Kürzeste Pfade

Übersicht

1 Kürzeste Pfade

2 Single-Source Shortest Path Bellman-Ford

Dijkstra

3 All-Pairs Shortest Paths Transitive Hülle

Algorithmus von Warshall Der Algorithmus von Floyd

(4)

Das Rechenproblem: kürzeste Pfade

(5)

Das Rechenproblem: kürzeste Pfade

(6)

Andere Rechenprobleme: kürzester Weg

Beispiel (kürzester Weg)

Eingabe: 1. Eine Straßenkarte, auf der der Abstand zwischen jedem Paar benachbarter Kreuzungen eingezeichnet ist, 2. eine Startkreuzung s , und

3. eine Zielkreuzung t.

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

(7)

Kürzeste Pfade

Gegeben sei ein (kanten-)gewichteter Graph G = (V , E , W ).

Das Gewicht eines Pfades ist die Summe der Gewichte seiner Kanten. Ein kürzester Pfad von einem Knoten s ∈ V zu einem anderen Knoten v ∈ V ist ein Pfad von s nach v mit minimalem Gewicht.

Sei im Folgenden δ : (V × V ) → ( R ∪ {+inf}) eine Funktion, sodaß:

I δ(s , v) ist das Gewicht des kürzesten Pfades von s nach v , und

I δ(s , v) = +inf gdw. v von s nicht erreichbar ist.

(8)

Kürzeste Pfade

Gegeben sei ein (kanten-)gewichteter Graph G = (V , E , W ).

Das Gewicht eines Pfades ist die Summe der Gewichte seiner Kanten.

Ein kürzester Pfad von einem Knoten s ∈ V zu einem anderen Knoten v ∈ V ist ein Pfad von s nach v mit minimalem Gewicht.

Sei im Folgenden δ : (V × V ) → ( R ∪ {+inf}) eine Funktion, sodaß:

I δ(s , v) ist das Gewicht des kürzesten Pfades von s nach v , und

I δ(s , v) = +inf gdw. v von s nicht erreichbar ist.

(9)

Kürzeste Pfade

Gegeben sei ein (kanten-)gewichteter Graph G = (V , E , W ).

Das Gewicht eines Pfades ist die Summe der Gewichte seiner Kanten.

Ein kürzester Pfad von einem Knoten s ∈ V zu einem anderen Knoten v ∈ V ist ein Pfad von s nach v mit minimalem Gewicht.

Sei im Folgenden δ : (V × V ) → ( R ∪ {+inf}) eine Funktion, sodaß:

I δ(s , v) ist das Gewicht des kürzesten Pfades von s nach v , und

I δ(s , v) = +inf gdw. v von s nicht erreichbar ist.

(10)

Kürzeste Pfade

Gegeben sei ein (kanten-)gewichteter Graph G = (V , E , W ).

Das Gewicht eines Pfades ist die Summe der Gewichte seiner Kanten.

Ein kürzester Pfad von einem Knoten s ∈ V zu einem anderen Knoten v ∈ V ist ein Pfad von s nach v mit minimalem Gewicht.

Sei im Folgenden δ : (V × V ) → ( R ∪ {+inf}) eine Funktion, sodaß:

I δ(s , v) ist das Gewicht des kürzesten Pfades von s nach v , und

I δ(s , v) = +inf gdw. v von s nicht erreichbar ist.

(11)

Kürzeste Pfade

Es gibt verschiedene Varianten:

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ürzeste Pfade für ein festes Knotenpaar u, v.

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

I Kürzeste Pfade für alle Knotenpaare.

All-Pairs Shortest Paths (zweiter Teil dieser Vorlesung).

(12)

Kürzeste Pfade

Es gibt verschiedene Varianten:

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ürzeste Pfade für ein festes Knotenpaar u, v.

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

I Kürzeste Pfade für alle Knotenpaare.

All-Pairs Shortest Paths (zweiter Teil dieser Vorlesung).

(13)

Kürzeste Pfade

Es gibt verschiedene Varianten:

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ürzeste Pfade für ein festes Knotenpaar u, v.

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

I Kürzeste Pfade für alle Knotenpaare.

All-Pairs Shortest Paths (zweiter Teil dieser Vorlesung).

(14)

Kürzeste Pfade

Es gibt verschiedene Varianten:

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ürzeste Pfade für ein festes Knotenpaar u, v.

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

I Kürzeste Pfade für alle Knotenpaare.

All-Pairs Shortest Paths (zweiter Teil dieser Vorlesung).

(15)

Kürzeste Pfade

Es gibt verschiedene Varianten:

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ürzeste Pfade für ein festes Knotenpaar u, v.

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

I Kürzeste Pfade für alle Knotenpaare.

All-Pairs Shortest Paths (zweiter Teil dieser Vorlesung).

(16)

Kürzeste Pfade

Es gibt verschiedene Varianten:

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ürzeste Pfade für ein festes Knotenpaar u, v.

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

I Kürzeste Pfade für alle Knotenpaare.

All-Pairs Shortest Paths (zweiter Teil dieser Vorlesung).

(17)

Kürzeste Pfade

Es gibt verschiedene Varianten:

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ürzeste Pfade für ein festes Knotenpaar u, v.

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

I Kürzeste Pfade für alle Knotenpaare.

All-Pairs Shortest Paths (zweiter Teil dieser Vorlesung).

(18)

Kürzeste Pfadalgorithmen Single-Source Shortest Path

Übersicht

1 Kürzeste Pfade

2 Single-Source Shortest Path Bellman-Ford

Dijkstra

3 All-Pairs Shortest Paths Transitive Hülle

Algorithmus von Warshall Der Algorithmus von Floyd

(19)

Single-Source Shortest Paths

Problem (Single-Source Shortest Path)

Für einen gegebenen Knoten s ∈ V (die Quelle / source), bestimme für jeden anderen Knoten t ∈ V , der aus s erreichbar ist, einen kürzesten Pfad von s zu t.

(20)

Übersicht

1 Kürzeste Pfade

2 Single-Source Shortest Path Bellman-Ford

Dijkstra

3 All-Pairs Shortest Paths Transitive Hülle

Algorithmus von Warshall Der Algorithmus von Floyd

(21)

Der Bellman-Ford Algorithmus

I Kürzeste Pfade bei einem einzigen Startknoten.

I Erlaubt negative Kantengewichte.

I Er zeigt an, ob es einen Zyklus mit negativem Gewicht gibt, der vom Startknoten aus erreichbar ist.

I Falls ein solcher Zyklus gefunden wird, gibt es keine Lösung

I

(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] an δ(s , v ), bis das Minimum gefunden wird.

I Kürzeste Pfade können nach Terminierung mittels die im Array prev gespeicherten Vorgängerknoten entlang eines kürzesten Pfades konstruiert werden.

(22)

Der Bellman-Ford Algorithmus

I Kürzeste Pfade bei einem einzigen Startknoten.

I Erlaubt negative Kantengewichte.

I Er zeigt an, ob es einen Zyklus mit negativem Gewicht gibt, der vom Startknoten aus erreichbar ist.

I Falls ein solcher Zyklus gefunden wird, gibt es keine Lösung

I

(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] an δ(s , v ), bis das Minimum gefunden wird.

I Kürzeste Pfade können nach Terminierung mittels die im Array prev gespeicherten Vorgängerknoten entlang eines kürzesten Pfades konstruiert werden.

(23)

Der Bellman-Ford Algorithmus

I Kürzeste Pfade bei einem einzigen Startknoten.

I Erlaubt negative Kantengewichte.

I Er zeigt an, ob es einen Zyklus mit negativem Gewicht gibt, der vom Startknoten aus erreichbar ist.

I Falls ein solcher Zyklus gefunden wird, gibt es keine Lösung

I

(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] an δ(s , v ), bis das Minimum gefunden wird.

I Kürzeste Pfade können nach Terminierung mittels die im Array prev gespeicherten Vorgängerknoten entlang eines kürzesten Pfades konstruiert werden.

(24)

Der Bellman-Ford Algorithmus

I Kürzeste Pfade bei einem einzigen Startknoten.

I Erlaubt negative Kantengewichte.

I Er zeigt an, ob es einen Zyklus mit negativem Gewicht gibt, der vom Startknoten aus erreichbar ist.

I Falls ein solcher Zyklus gefunden wird, gibt es keine Lösung

I

(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] an δ(s , v ), bis das Minimum gefunden wird.

I Kürzeste Pfade können nach Terminierung mittels die im Array prev gespeicherten Vorgängerknoten entlang eines kürzesten Pfades konstruiert werden.

(25)

Der Bellman-Ford Algorithmus

I Kürzeste Pfade bei einem einzigen Startknoten.

I Erlaubt negative Kantengewichte.

I Er zeigt an, ob es einen Zyklus mit negativem Gewicht gibt, der vom Startknoten aus erreichbar ist.

I Falls ein solcher Zyklus gefunden wird, gibt es keine Lösung

I

(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] an δ(s , v), bis das Minimum gefunden wird.

I Kürzeste Pfade können nach Terminierung mittels die im Array prev gespeicherten Vorgängerknoten entlang eines kürzesten Pfades konstruiert werden.

(26)

Der Bellman-Ford Algorithmus

I Kürzeste Pfade bei einem einzigen Startknoten.

I Erlaubt negative Kantengewichte.

I Er zeigt an, ob es einen Zyklus mit negativem Gewicht gibt, der vom Startknoten aus erreichbar ist.

I Falls ein solcher Zyklus gefunden wird, gibt es keine Lösung

I

(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] an δ(s , v), bis das Minimum gefunden wird.

I Kürzeste Pfade können nach Terminierung mittels die im Array prev gespeicherten Vorgängerknoten entlang eines kürzesten Pfades konstruiert werden.

(27)

Bellman-Ford: Idee

I Initialisierung: dist[v]=+inf , dist[start]=0 .

I Für alle Kanten (v , w ) ∈ E :

I

Relaxierung: Ist das bisher bekannte Gewicht dist[w] größer als dist[v] + W(v,w), dann verbessere dist[w] auf diesen Wert.

I Wiederhole den vorigen Schritt bis sich nichts mehr ändert, bzw. breche ab, falls ein negativer Zyklus gefunden wurde.

Korrektheit vom Bellman-Ford Algorithmus

Wenn nach |V |−1 Iterationen noch Verbesserungen möglich sind, dann gibt es einen negativen Zyklus. Andernfalls dist[v] = δ(s, v ) für alle v ∈ V .

Beweis.

Beweisidee: Ein Pfad ohne Zyklen in (V , E , W ) hat eine Länge 6 |V |−1.

(28)

Bellman-Ford: Idee

I Initialisierung: dist[v]=+inf , dist[start]=0 .

I Für alle Kanten (v , w ) ∈ E :

I

Relaxierung: Ist das bisher bekannte Gewicht dist[w] größer als dist[v] + W(v,w), dann verbessere dist[w] auf diesen Wert.

I Wiederhole den vorigen Schritt bis sich nichts mehr ändert, bzw. breche ab, falls ein negativer Zyklus gefunden wurde.

Korrektheit vom Bellman-Ford Algorithmus

Wenn nach |V |−1 Iterationen noch Verbesserungen möglich sind, dann gibt es einen negativen Zyklus. Andernfalls dist[v] = δ(s, v ) für alle v ∈ V .

Beweis.

Beweisidee: Ein Pfad ohne Zyklen in (V , E , W ) hat eine Länge 6 |V |−1.

(29)

Bellman-Ford: Idee

I Initialisierung: dist[v]=+inf , dist[start]=0 .

I Für alle Kanten (v , w ) ∈ E :

I

Relaxierung: Ist das bisher bekannte Gewicht dist[w] größer als dist[v] + W(v,w), dann verbessere dist[w] auf diesen Wert.

I Wiederhole den vorigen Schritt bis sich nichts mehr ändert, bzw.

breche ab, falls ein negativer Zyklus gefunden wurde.

Korrektheit vom Bellman-Ford Algorithmus

Wenn nach |V |−1 Iterationen noch Verbesserungen möglich sind, dann gibt es einen negativen Zyklus. Andernfalls dist[v] = δ(s, v ) für alle v ∈ V .

Beweis.

Beweisidee: Ein Pfad ohne Zyklen in (V , E , W ) hat eine Länge 6 |V |−1.

(30)

Bellman-Ford: Idee

I Initialisierung: dist[v]=+inf , dist[start]=0 .

I Für alle Kanten (v , w ) ∈ E :

I

Relaxierung: Ist das bisher bekannte Gewicht dist[w] größer als dist[v] + W(v,w), dann verbessere dist[w] auf diesen Wert.

I Wiederhole den vorigen Schritt bis sich nichts mehr ändert, bzw.

breche ab, falls ein negativer Zyklus gefunden wurde.

Korrektheit vom Bellman-Ford Algorithmus

Wenn nach |V |−1 Iterationen noch Verbesserungen möglich sind, dann gibt es einen negativen Zyklus. Andernfalls dist[v] = δ(s, v ) für alle v ∈ V .

Beweis.

Beweisidee: Ein Pfad ohne Zyklen in (V , E , W ) hat eine Länge 6 |V |−1.

(31)

Bellman-Ford in Pseudo-Code

1

bool bellmanFord(List adj[n], int n, int start,

2

int &dist[n], int &prev[n]) {

3

for (int v = 0; v < n; v++) { // für alle Knoten v

4

dist[v] = +inf; // +inf ist initiale Entfernung von start zu v

5

prev[v] = -1; // v hat noch kein Vorgänger

6

}

7

dist[start] = 0; // die Entfernung von start zu start ist 0

8

for (int i = 1; i < n; i++) // n-1 Durchläufe

9

for (int v = 0; v < n; v++) // für alle Knoten v

10

foreach (edge in adj[v]) // für jede aus v ausgehende Kante

11

if (dist[edge.target] > dist[v] + edge.weight) {

12

dist[edge.target] = dist[v] + edge.weight;

13

prev[edge.target] = v;

14

} // Relaxierung

15

for (int v = 0; v < n; v++) // für alle Knoten v

16

foreach (edge in adj[v]) // für jede aus v ausgehende Kante

17

if (dist[edge.target] > dist[v] + edge.weight)

18

return false; // es existiert Zyklus mit negativem Gewicht

19

return true;

20

}

I Zeitkomplexität: O(|V | · |E |).

(32)

Bellman-Ford in Pseudo-Code

1

bool bellmanFord(List adj[n], int n, int start,

2

int &dist[n], int &prev[n]) {

3

for (int v = 0; v < n; v++) { // für alle Knoten v

4

dist[v] = +inf; // +inf ist initiale Entfernung von start zu v

5

prev[v] = -1; // v hat noch kein Vorgänger

6

}

7

dist[start] = 0; // die Entfernung von start zu start ist 0

8

for (int i = 1; i < n; i++) // n-1 Durchläufe

9

for (int v = 0; v < n; v++) // für alle Knoten v

10

foreach (edge in adj[v]) // für jede aus v ausgehende Kante

11

if (dist[edge.target] > dist[v] + edge.weight) {

12

dist[edge.target] = dist[v] + edge.weight;

13

prev[edge.target] = v;

14

} // Relaxierung

15

for (int v = 0; v < n; v++) // für alle Knoten v

16

foreach (edge in adj[v]) // für jede aus v ausgehende Kante

17

if (dist[edge.target] > dist[v] + edge.weight)

18

return false; // es existiert Zyklus mit negativem Gewicht

19

return true;

20

}

I Zeitkomplexität:

O(|V | · |E |).

(33)

Bellman-Ford in Pseudo-Code

1

bool bellmanFord(List adj[n], int n, int start,

2

int &dist[n], int &prev[n]) {

3

for (int v = 0; v < n; v++) { // für alle Knoten v

4

dist[v] = +inf; // +inf ist initiale Entfernung von start zu v

5

prev[v] = -1; // v hat noch kein Vorgänger

6

}

7

dist[start] = 0; // die Entfernung von start zu start ist 0

8

for (int i = 1; i < n; i++) // n-1 Durchläufe

9

for (int v = 0; v < n; v++) // für alle Knoten v

10

foreach (edge in adj[v]) // für jede aus v ausgehende Kante

11

if (dist[edge.target] > dist[v] + edge.weight) {

12

dist[edge.target] = dist[v] + edge.weight;

13

prev[edge.target] = v;

14

} // Relaxierung

15

for (int v = 0; v < n; v++) // für alle Knoten v

16

foreach (edge in adj[v]) // für jede aus v ausgehende Kante

17

if (dist[edge.target] > dist[v] + edge.weight)

18

return false; // es existiert Zyklus mit negativem Gewicht

19

return true;

20

}

I Zeitkomplexität: O(|V | · |E |).

(34)

Bellman-Ford – Beispiel

0 ∞

∞ ∞

∞

∞ ∞

14

6

4

10

9 -12 3

3

8

2

15

(35)

Bellman-Ford – Beispiel

0

14 ∞ ∞

∞

∞ ∞

14

6

4

10

9 -12 3

3

8

2

15

(36)

Bellman-Ford – Beispiel

0

14 ∞ ∞

6 ∞

∞ ∞

14

6

4

10

9 -12 3

3

8

2

15

(37)

Bellman-Ford – Beispiel

0

14 ∞ ∞

6 ∞

∞ ∞

14

6

4

10

9 -12 3

3

8

2

15

(38)

Bellman-Ford – Beispiel

0

14 18 ∞

6 ∞

∞ ∞

14

6

4

10

9 -12 3

3

8

2

15

(39)

Bellman-Ford – Beispiel

0

14 18 ∞

6

24 ∞ ∞

14

6

4

10

9 -12 3

3

8

2

15

(40)

Bellman-Ford – Beispiel

0

14 18 ∞

6

24 ∞ ∞

14

6

4

10

9 -12 3

3

8

2

15

(41)

Bellman-Ford – Beispiel

0

14 18 27

6

24 ∞ ∞

14

6

4

10

9 -12 3

3

8

2

15

(42)

Bellman-Ford – Beispiel

0

14 18 27

6

24 ∞ ∞

14

6

4

10

9 -12 3

3

8

2

15

(43)

Bellman-Ford – Beispiel

0

14 18 27

6

24 15 ∞

14

6

4

10

9 -12 3

3

8

2

15

(44)

Bellman-Ford – Beispiel

0

14 18 27

6

24 15 ∞

14

6

4

10

9 -12 3

3

8

2

15

(45)

Bellman-Ford – Beispiel

0

9 18 27

6

24 15 ∞

14

6

4

10

9 -12 3

3

8

2

15

(46)

Bellman-Ford – Beispiel

0

9 18 27

6

24 15 ∞

14

6

4

10

9 -12 3

3

8

2

15

(47)

Bellman-Ford – Beispiel

0

9 18 27

6

24 15 ∞

14

6

4

10

9 -12 3

3

8

2

15

(48)

Bellman-Ford – Beispiel

0

9 17 27

6

24 15 ∞

14

6

4

10

9 -12 3

3

8

2

15

(49)

Bellman-Ford – Beispiel

0

9 17 27

6

24 15 30

14

6

4

10

9 -12 3

3

8

2

15

(50)

Bellman-Ford – Beispiel

0

9 17 27

6

24 15 30

14

6

4

10

9 -12 3

3

8

2

15

(51)

Bellman-Ford – Beispiel

0

9 17 27

6

24 15 30

14

6

4

10

9 -12 3

3

8

2

15

(52)

Bellman-Ford – Beispiel

0

9 17 27

6

24 15 30

14

6

4

10

9 -12 3

3

8

2

15

(53)

Bellman-Ford – Beispiel

0

9 13 27

6

24 15 30

14

6

4

10

9 -12 3

3

8

2

15

(54)

Bellman-Ford – Beispiel

0

9 13 27

6

19 15 30

14

6

4

10

9 -12 3

3

8

2

15

(55)

Bellman-Ford – Beispiel

0

9 13 27

6

19 15 30

14

6

4

10

9 -12 3

3

8

2

15

(56)

Bellman-Ford – Beispiel

0

9 13 22

6

19 15 30

14

6

4

10

9 -12 3

3

8

2

15

(57)

Bellman-Ford – Beispiel

0

9 13 22

6

19 15 30

14

6

4

10

9 -12 3

3

8

2

15

(58)

Bellman-Ford – Beispiel

0

9 13 22

6

19 10 30

14

6

4

10

9 -12 3

3

8

2

15

(59)

Bellman-Ford – Beispiel

0

9 13 22

6

19 10 30

14

6

4

10

9 -12 3

3

8

2

15

(60)

Bellman-Ford – Beispiel

0

9 13 22

6

19 10 30

14

6

4

10

9 -12 3

3

8

2

15

(61)

Bellman-Ford – Beispiel

0

9 13 22

6

19 10 30

14

6

4

10

9 -12 3

3

8

2

15

(62)

Bellman-Ford – Beispiel

0

9 12 22

6

19 10 30

14

6

4

10

9 -12 3

3

8

2

15

(63)

Bellman-Ford – Beispiel

0

9 12 22

6

19 10 25

14

6

4

10

9 -12 3

3

8

2

15

(64)

Bellman-Ford – Beispiel

0

9 12 22

6

19 10 25

14

6

4

10

9 -12 3

3

8

2

15

(65)

Bellman-Ford – Beispiel

0

9 12 22

6

19 10 25

14

6

4

10

9 -12 3

3

8

2

15

(66)

Bellman-Ford – Beispiel

0

9 12 22

6

19 10 25

14

6

4

10

9 -12 3

3

8

2

15

(67)

Bellman-Ford – Beispiel

0

9 12 22

6

19 10 25

14

6

4

10

9 -12 3

3

8

2

15

(68)

Bellman-Ford – Beispiel

0

9 12 21

6

19 10 25

14

6

4

10

9 -12 3

3

8

2

15

(69)

Bellman-Ford – Beispiel

0

9 12 21

6

19 10 25

14

6

4

10

9 -12 3

3

8

2

15

(70)

Bellman-Ford – Beispiel

0

9 12 21

6

19 9 25

14

6

4

10

9 -12 3

3

8

2

15

(71)

Bellman-Ford – Beispiel

0

9 12 21

6

19 9 25

14

6

4

10

9 -12 3

3

8

2

15

(72)

Bellman-Ford – Beispiel

0

9 12 21

6

19 9 25

14

6

4

10

9 -12 3

3

8

2

15

(73)

Bellman-Ford – Beispiel

0

9 12 21

6

19 9 25

14

6

4

10

9 -12 3

3

8

2

15

(74)

Bellman-Ford – Beispiel

0

9 11 21

6

19 9 25

14

6

4

10

9 -12 3

3

8

2

15

(75)

Bellman-Ford – Beispiel

0

9 11 21

6

19 9 24

14

6

4

10

9 -12 3

3

8

2

15

(76)

Bellman-Ford – Beispiel

0

9 11 21

6

19 9 24

14

6

4

10

9 -12 3

3

8

2

15

(77)

Bellman-Ford – Beispiel

0

9 11 21

6

19 9 24

14

6

4

10

9 -12 3

3

8

2

15

(78)

Bellman-Ford – Beispiel

0

9 11 21

6

19 9 24

14

6

4

10

9 -12 3

3

8

2

15

(79)

Bellman-Ford – Beispiel

0

9 11 21

6

19 9 24

14

6

4

10

9 -12 3

3

8

2

15

(80)

Bellman-Ford – Beispiel

0

9 11 20

6

19 9 24

14

6

4

10

9 -12 3

3

8

2

15

(81)

Bellman-Ford – Beispiel

0

9 11 20

6

19 9 24

14

6

4

10

9 -12 3

3

8

2

15

(82)

Bellman-Ford – Beispiel

0

9 11 20

6

19 8 24

14

6

4

10

9 -12 3

3

8

2

15

(83)

Bellman-Ford – Beispiel

0

9 11 20

6

19 8 24

14

6

4

10

9 -12 3

3

8

2

15

(84)

Bellman-Ford – Beispiel

0

9 11 20

6

19 8 24

14

6

4

10

9 -12 3

3

8

2

15

(85)

Bellman-Ford – Beispiel

0

9 11 20

6

19 8 24

14

6

4

10

9 -12 3

3

8

2

15

(86)

Bellman-Ford – Beispiel

0

9 10 20

6

19 8 24

14

6

4

10

9 -12 3

3

8

2

15

(87)

Bellman-Ford – Beispiel

0

9 10 20

6

19 8 23

14

6

4

10

9 -12 3

3

8

2

15

(88)

Bellman-Ford – Beispiel

0

9 10 20

6

19 8 23

14

6

4

10

9 -12 3

3

8

2

15

(89)

Bellman-Ford – Beispiel

0

9 10 20

6

19 8 23

14

6

4

10

9 -12 3

3

8

2

15

(90)

Übersicht

1 Kürzeste Pfade

2 Single-Source Shortest Path Bellman-Ford

Dijkstra

3 All-Pairs Shortest Paths Transitive Hülle

Algorithmus von Warshall Der Algorithmus von Floyd

(91)

Dijkstras Algorithmus

Annahme

Kantengewichte sind nicht-negativ, d. h. W (v , w ) > 0 für all (v, w ) ∈ E .

I Also: Kürzeste Pfade enthalten keine Zyklen.

Edsger Wybe Dijkstra (1930-2002), Turing Award 1972

(92)

Dijkstras Algorithmus: Übersicht

Wie beim Algorithmus von Prim ordnen wir die Knoten in drei Kategorien:

Baumknoten: Knoten, die Teil vom bis jetzt konstruierten Baum sind.

Randknoten: Nicht im Baum, jedoch adjazent zu Knoten im Baum.

Ungesehene Knoten: Alle anderen Knoten.

Grundkonzept:

I Kein Knoten außerhalb des Baumes hat einen kürzeren Pfad als die Knoten im Baum.

I Jedem Knoten v ist ein Wert dist[v] zugeordnet. Dieser Wert ist:

I

für Baumknoten dist[v] = δ(s, v);

I

für Randknoten das Minimum der Gewichte aller Pfade vom Startknoten zu v, wobei die letzte Kante im Schnitt liegt;

I

für ungesehenen Knoten +inf.

(93)

Dijkstras Algorithmus: Übersicht

Wie beim Algorithmus von Prim ordnen wir die Knoten in drei Kategorien:

Baumknoten: Knoten, die Teil vom bis jetzt konstruierten Baum sind.

Randknoten: Nicht im Baum, jedoch adjazent zu Knoten im Baum.

Ungesehene Knoten: Alle anderen Knoten.

Grundkonzept:

I Kein Knoten außerhalb des Baumes hat einen kürzeren Pfad als die Knoten im Baum.

I Jedem Knoten v ist ein Wert dist[v] zugeordnet. Dieser Wert ist:

I

für Baumknoten dist[v] = δ(s, v);

I

für Randknoten das Minimum der Gewichte aller Pfade vom Startknoten zu v, wobei die letzte Kante im Schnitt liegt;

I

für ungesehenen Knoten +inf.

(94)

Dijkstras Algorithmus: Übersicht

Wie beim Algorithmus von Prim ordnen wir die Knoten in drei Kategorien:

Baumknoten: Knoten, die Teil vom bis jetzt konstruierten Baum sind.

Randknoten: Nicht im Baum, jedoch adjazent zu Knoten im Baum.

Ungesehene Knoten: Alle anderen Knoten.

Grundkonzept:

I Kein Knoten außerhalb des Baumes hat einen kürzeren Pfad als die Knoten im Baum.

I Jedem Knoten v ist ein Wert dist[v] zugeordnet. Dieser Wert ist:

I

für Baumknoten dist[v] = δ(s, v);

I

für Randknoten das Minimum der Gewichte aller Pfade vom Startknoten zu v, wobei die letzte Kante im Schnitt liegt;

I

für ungesehenen Knoten +inf.

(95)

Dijkstras Kürzeste-Wege-Algorithmus – Grundgerüst

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 adjazenten Knoten als Rand (GRAY);

6

while (es gibt Randknoten) {

7

wähle von allen Kanten zwischen einem Baumknoten t und

8

einem Randknoten v mit minimalem d(s, t) + W (t, v);

9

reklassifiziere v als Baum (BLACK);

10

füge Kante (t, v) zum Baum hinzu;

11

setze d(s, v ) = d(s, t) + W (t, v);

12

reklassifiziere alle zu v adjazenten ungesehenen Knoten

13

mit Rand (GRAY);

14

}

15

}

Unterschiede zu Prim’s Algorithmus sind in rot gekennzeichnet.

(96)

Dijkstras Kürzeste-Wege-Algorithmus – Beispiel

0 ∞

∞

∞ ∞

∞ 14

6 10 5 5

3 3

4 4

8 8

2 15 15 9 9

(97)

Dijkstras Kürzeste-Wege-Algorithmus – Beispiel

0

14

6

10 ∞

5 ∞

∞ 14

6 10 5 5

3 3

4 4

8 8

2 15 15 9 9

(98)

Dijkstras Kürzeste-Wege-Algorithmus – Beispiel

0

14

6

10

7 5 14

∞ 14

6 10 5 5

3 3

4 4

8 8

2 15 15 9 9

(99)

Dijkstras Kürzeste-Wege-Algorithmus – Beispiel

0

14

6

10

7 5 14

∞ 14

6 10 5 5

3 3

4 4

8 8

2 15 15 9 9

(100)

Dijkstras Kürzeste-Wege-Algorithmus – Beispiel

0

14

6

10

7 5 14

22 14

6 10 5 5

3 3

4 4

8 8

2 15 15 9 9

(101)

Dijkstras Kürzeste-Wege-Algorithmus – Beispiel

0

13

6

10

7 5 14

22 14

6 10 5 5

3 3

4 4

8 8

2 15 15 9 9

(102)

Dijkstras Kürzeste-Wege-Algorithmus – Beispiel

0

13

6

10

7 5 14

22 14

6 10 5 5

3 3

4 4

8 8

2 15 15 9 9

(103)

Dijkstras Kürzeste-Wege-Algorithmus – Beispiel

0

13

6

10

7 5 14

22 14

6 10 5 5

3 3

4 4

8 8

2 15 15 9 9

(104)

Dijkstras Kürzeste-Wege-Algorithmus – Beispiel

0

13

6

10

7 5 14

22 14

6 10 5 5

3 3

4 4

8 8

2 15 15 9 9

(105)

Dijkstras Algorithmus: Korrektheit

Theorem

Sei B der schon konstruierte (schwarze) Teilbaum. Es 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) 6 δ(s, u) für alle Baumknoten v ∈ B und u ∈ V \ B.

(106)

Dijkstras Algorithmus: Korrektheit

Theorem

Sei B der schon konstruierte (schwarze) Teilbaum. Es 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) 6 δ(s, u) für alle Baumknoten v ∈ B und u ∈ V \ B.

(107)

Dijkstras Algorithmus: Korrektheit

Theorem

Sei B der schon konstruierte (schwarze) Teilbaum. Es 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) 6 δ(s, u) für alle Baumknoten v ∈ B und u ∈ V \ B.

(108)

Dijkstras Algorithmus: Korrektheit

Theorem

Sei B der schon konstruierte (schwarze) Teilbaum. Es 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) 6 δ(s, u) für alle Baumknoten v ∈ B und u ∈ V \ B.

(109)

Dijkstras Algorithmus: Korrektheit

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 v ∈ V \ B;

4. δ(s, v ) 6 δ(s, u) für alle Baumknoten v ∈ B und u ∈ V \ B.

Beweis.

1., 3. und 4. sind (ziemlich) trivial. Betrachte 2.

Per Induktion über die Anzahl der Baumknoten. Beweisskizze:

I Basis: B ist leer und B = {s } (nach der ersten Iteration): trivial.

I Ind. Schritt: nehme an, das Theorem gilt für |B| = k > 0. Sei v der Knoten der als nächste zum Baum B hinzugefügt wird. Der Fall dist[v] = +inf ist trivial. Betrachte dist[v] 6= +inf. Dann gibt es eine Kante vom Baumknoten

x = prev[v] ∈ B zu v 6∈ 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 ).