dis[ v ] und nC ) ··· v ] rrrrrrr 6HHHY rrrrrrr - 2.2Dijkstra’sAlgorithmusmitRadix-Heaps dis[ d( v ) v ∈ ]dis[ [0 ,...,C ] (alleWertesindzwischen sS v ] dis[ v ]dis[ vv + ∞

(1)

2.2 Dijkstra’s Algorithmus mit Radix-Heaps

dis[v] dis[v ⁰ ]

r r r r · · · r r r

d(v) ∈ [0, . . . , C] (alle Werte sind zwischen dis[v] und nC)

dis[v] dis[v ⁰ ] 6 H Y H H

v v ⁰ +∞

s S

r r r r r r - r

EADS 2.2 Dijkstra’s Algorithmus mit Radix-Heaps 456/476

ľErnst W. Mayr

(2)

Wir verwenden Radix-Heaps (siehe dort), in der einstufigen Variante wie vorgestellt.

Satz 109

Dijkstra’s Algorithmus mit einstufigen Radix-Heaps hat Zeitkomplexit¨ at O(m + n log C).

Beweis:

siehe Satz 71.

ľErnst W. Mayr

(3)

Verbesserungen:

1

zweistufige Heaps: O(m + n · _{log log} ^log ^C _C )

2

mehrstufige Heaps (+Fibonacci-Heaps): O(m + n √ log C)

R.K. Ahuja, Kurt Mehlhorn, J.B. Orlin, R.E. Tarjan:

Faster algorithms for the shortest path problem J. ACM 37(2), pp. 213–223 (1990)

ľErnst W. Mayr

(4)

2.3 Bellman-Ford-Algorithmus

Dieser Algorithmus ist ein Beispiel f¨ ur dynamische Programmierung.

Sei B _k [i] := L¨ ange eines k¨ urzesten Pfades von s zum Knoten i, wobei der Pfad h¨ ochstens k Kanten enth¨ alt.

Gesucht ist B n−1 [i] f¨ ur i = 1, . . . , n (o.B.d.A. V = {1, . . . , n}).

EADS 2.3 Bellman-Ford-Algorithmus 459/476

ľErnst W. Mayr

(5)

Initialisierung:

B 1 [i] :=



 

 

d(s, i) , falls d(s, i) < ∞, i 6= s 0 , falls i = s

+∞ , sonst Iteration:

for k := 2 to n − 1 do for i := 1 to n do

B _k [i] :=

0 , falls i = s

min _j∈N

⁻¹

_(i) {B k−1 [i], B k−1 [j] + d(j, i)} , sonst od

od

Bemerkung: N ⁻¹ (i) ist die Menge der Knoten, von denen aus eine Kante zu Knoten i f¨ uhrt.

ľErnst W. Mayr

(6)

Korrekheit:

klar (Beweis durch vollst¨ andige Induktion) Zeitbedarf:

Man beachte, dass in jedem Durchlauf der ¨ außeren Schleife jede Halbkante einmal ber¨ uhrt wird.

Satz 110

Der Zeitbedarf des Bellman-Ford-Algorithmus ist O(n · m).

Beweis:

s.o.

ľErnst W. Mayr

(7)

3. Floyd’s Algorithmus f¨ ur das all-pairs-shortest-path-Problem Dieser Algorithmus wird auch als

” Kleene’s Algorithmus“

bezeichnet. Er ist ein weiteres Beispiel f¨ ur dynamische Programmierung.

Sei G = (V, E) mit Distanzfunktion d : A → R ⁺ ₀ gegeben. Sei o.B.d.A. V = {v ₁ , . . . , v n }.

Wir setzen nun

c ^k _ij := L¨ ange eines k¨ urzesten Pfades von v i nach v j , der als innere Knoten (alle bis auf ersten und letzten Knoten) nur Knoten aus {v ₁ , . . . , v _k } enth¨ alt.

ľErnst W. Mayr

(8)

algorithm floyd :=

for alle (i, j) do c ⁽⁰⁾ _ij := d(i, j) od ; 1 ≤ i, j ≤ n for k := 1 to n do

for alle (i, j), 1 ≤ i, j ≤ n do c ^(k) _ij := min

n

c ^(k−1) _ij , c ^(k−1) _ik + c ^(k−1) _kj o od

od

ľErnst W. Mayr

(9)

Laufzeit: O(n ³ ) Korrektheit:

Zu zeigen: c ^(k) _ij des Algorithmus = c ^k _ij (damit sind die L¨ angen der k¨ urzesten Pfade durch c ⁽ⁿ⁾ _ij gegeben).

Beweis:

Richtig f¨ ur k = 0. Induktionsschluss: Ein k¨ urzester Pfad von v i

nach v _j mit inneren Knoten ∈ {v ₁ , . . . , v _k+1 } enth¨ alt entweder v _k+1 gar nicht als inneren Knoten, oder er enth¨ alt v _k+1 genau einmal als inneren Knoten. Im ersten Fall wurde dieser Pfad also bereits f¨ ur c ^(k) _ij betrachtet, hat also L¨ ange = c ^(k) _ij . Im zweiten Fall setzt er sich aus einem k¨ urzesten Pfad P ₁ von v _i nach v _k+1 und einem k¨ urzesten Pfad P 2 von v k+1 nach v j zusammen, wobei alle inneren Knoten von P 1 und P 2 ∈ {v ₁ , . . . , v _k } sind. Also ist die L¨ ange des Pfades = c ^(k) _i,k+1 + c ^(k) _k+1,j .

ľErnst W. Mayr

(10)

Satz 111

Floyd’s Algorithmus f¨ ur das all-pairs-shortest-path-Problem hat Zeitkomplexit¨ at O(n ³ ).

ľErnst W. Mayr

(11)

4. Digraphen mit negativen Kantengewichten 4.1 Grunds¨ atzliches

Betrachte Startknoten s und einen Kreis C mit Gesamtl¨ ange < 0.

t t t t

t t

t - - ppppppppp -

J J

J J ^ -

Q Q Q Q Q k

+ -

s

k ₀

k 1 k 2

k ₃ k 4

1 3 2 v

1 1

1 −5 1 C

Sollte ein Pfad von s nach C und von C nach v existieren, so ist ein k¨ urzester Pfad von s nach v nicht definiert.

EADS 4.1 Grunds¨atzliches 466/476

ľErnst W. Mayr

(12)

Falls aber die Gesamtl¨ ange des Kreises C ≥ 0 ist,

t t t t

t t

- - ppppppppp - t J

J

J J ^ -

Q Q Q Q Q k

+ -

s

k 0

k ₁ k ₂

k 3

k 4

1 3 2 v

1 1 1

−3 1

dann ist der k¨ urzeste Pfad wohldefiniert. Probleme gibt es also nur dann, wenn G einen Zyklus negativer L¨ ange enth¨ alt.

ľErnst W. Mayr

(13)

Dijkstra’s Algorithmus funktioniert bei negativen Kantenl¨ angen nicht:

s

@

@ @

s v

w

3 −2

4 Bei diesem Beispielgraphen (der nicht einmal einen negativen Kreis enth¨ alt) berechnet der Dijkstra-Algorithmus die minimale

Entfernung von s nach w f¨ alschlicherweise als 3 (statt 2).

ľErnst W. Mayr

(14)

4.2 Modifikation des Bellman-Ford-Algorithmus

B k [i] gibt die L¨ ange eines k¨ urzesten gerichteten s-i-Pfades an, der aus h¨ ochstens k Kanten besteht. Jeder Pfad, der keinen Kreis enth¨ alt, besteht aus maximal n − 1 Kanten. In einem Graphen ohne negative Kreise gilt daher:

∀i ∈ V : B _n [i] ≥ B n−1 [i]

Gibt es hingegen einen (von s aus erreichbaren) Kreis negativer L¨ ange, so gibt es einen Knoten i ∈ V , bei dem ein Pfad aus n Kanten mit der L¨ ange B n [i] diesen Kreis h¨ aufiger durchl¨ auft als jeder Pfad aus maximal n − 1 Kanten der L¨ ange B n−1 [i].

Demnach gilt in diesem Fall:

B _n [i] < B n−1 [i]

EADS 4.2 Modifikation des Bellman-Ford-Algorithmus 469/476

ľErnst W. Mayr

(15)

Man kann also in den Algorithmus von Bellman-Ford einen Test auf negative Kreise einbauen, indem man auch f¨ ur alle i ∈ V B _n [i]

berechnet und am Ende den folgenden Befehl einf¨ ugt:

for i := 1 to n do

if B _n [i] < B n−1 [i] then stop

” Negativer Kreis“ fi

EADS 4.2 Modifikation des Bellman-Ford-Algorithmus 470/476

ľErnst W. Mayr

(16)

4.3 Modifikation des Floyd-Algorithmus

Falls kein negativer Kreis existiert, funktioniert der Algorithmus weiterhin korrekt.

t

t t

t

* H H

H H H j

? H H H H H Y 6 v ₁

v ₂

v ₃

v ₄ v 5

v 6

1 1

1 1 1

−6

c ⁶ ₁₆ = 5 = c ⁵ ₁₆ c ⁶ ₆₁ = −6 = c ⁵ ₆₁

c ⁶ ₁₁ = min{c ⁵ ₁₁ , c ⁵ ₁₆ +c ⁵ ₆₁ } = −1

⇒ der Graph enth¨ alt einen negativen Kreis, gdw ein c ⁿ _ii < 0 existiert.

EADS 4.3 Modifikation des Floyd-Algorithmus 471/476

ľErnst W. Mayr

(17)

Man kann also in den Algorithmus von Floyd einen Test auf negative Kreise einbauen, indem man am Ende den folgenden Befehl einf¨ ugt:

for i := 1 to n do if c ⁿ _ii < 0 then stop

” Negativer Kreis“ fi

EADS 4.3 Modifikation des Floyd-Algorithmus 472/476

ľErnst W. Mayr

(18)

4.4 Der Algorithmus von Johnson Definition 112

Sei d : A → R eine Distanzfunktion. Eine Abbildung r : V → R

heißt Rekalibrierung, falls gilt:

(∀(u, v) ∈ A)[r(u) + d(u, v) ≥ r(v)]

Beobachtung: Sei r eine Rekalibrierung (f¨ ur d). Setze d ⁰ (u, v) := d(u, v) + r(u) − r(v). Dann gilt:

d ⁰ (u, v) ≥ 0

EADS 4.4 Der Algorithmus von Johnson 473/476

ľErnst W. Mayr

(19)

Sei u = v ₀ → · · · → v _k = v ein Pfad. Dann ist:

d-L¨ ange :=

k−1

X

i=0

d(v _i , v _i+1 ) Demnach ist:

d ⁰ -L¨ ange =

k−1

X

i=0

d ⁰ (v _i , v _i+1 )

=

k−1

X

i=0

(d(v i , v i+1 ) + r(v i ) − r(v i+1 ))

=

k−1

X

i=0

d(v _i , v _i+1 ) + r(v ₀ ) − r(v _k )

Also ist ein d-k¨ urzester Pfad von u (= v ₀ ) nach v (= v _k ) auch ein d ⁰ -k¨ urzester Pfad und umgekehrt. Nach einer Rekalibrierung kann man also auch die Algorithmen anwenden, die eine nichtnegative Distanzfunktion d voraussetzen (z.B. Dijkstra).

ľErnst W. Mayr

(20)

Berechnung einer Rekalibrierung:

~

z

~ 0

0 0 s

s

' s

&

$

% s

u

v w

Graph G

d : A → R

F¨ uge einen neuen Knoten s hin- zu und verbinde s mit jedem an- deren Knoten v ∈ V durch eine Kante der L¨ ange 0.

Berechne sssp von s nach allen anderen Knoten v ∈ V (z.B. mit Bellman-Ford). Sei r(v) die dadurch berechnete Entfernung von s zu v ∈ V . Dann ist r eine Rekalibrierung, denn es gilt:

r(u) + d(u, v) ≥ r(v) .

ľErnst W. Mayr

(21)

5. Zusammenfassung

d ≥ 0 d allgemein

sssp D (Fibonacci): O(m + n · log n) B-F: O(n · m) D (Radix): O(m + n √

log C) apsp D: O(n · m + n ² min{log n, √

log C}) J: O(n · m + n ² log n)

F: O(n ³ ) ^(∗) F: O(n ³ )

Bemerkung ^(∗) : In der Praxis ist der Floyd-Algorithmus f¨ ur kleine n besser als Dijkstra’s Algorithmus.

ľErnst W. Mayr

dis[ v ] und nC ) ··· v ] rrrrrrr 6HHHY rrrrrrr - 2.2Dijkstra’sAlgorithmusmitRadix-Heaps dis[ d( v ) v ∈ ]dis[ [0 ,...,C ] (alleWertesindzwischen sS v ] dis[ v ]dis[ vv + ∞

2.2 Dijkstra’s Algorithmus mit Radix-Heaps

dis[v] dis[v 0 ]

r r r r · · · r r r

d(v) ∈ [0, . . . , C] (alle Werte sind zwischen dis[v] und nC)

dis[v] dis[v 0 ] 6 H Y H H

v v 0 +∞

s S

r r r r r r - r

Wir verwenden Radix-Heaps (siehe dort), in der einstufigen Variante wie vorgestellt.

Satz 109

Dijkstra’s Algorithmus mit einstufigen Radix-Heaps hat Zeitkomplexit¨ at O(m + n log C).

Beweis:

siehe Satz 71.

Verbesserungen:

zweistufige Heaps: O(m + n · log log log C C )

mehrstufige Heaps (+Fibonacci-Heaps): O(m + n √ log C)

R.K. Ahuja, Kurt Mehlhorn, J.B. Orlin, R.E. Tarjan:

Faster algorithms for the shortest path problem J. ACM 37(2), pp. 213–223 (1990)

2.3 Bellman-Ford-Algorithmus

Dieser Algorithmus ist ein Beispiel f¨ ur dynamische Programmierung.

Sei B k [i] := L¨ ange eines k¨ urzesten Pfades von s zum Knoten i, wobei der Pfad h¨ ochstens k Kanten enth¨ alt.

Gesucht ist B n−1 [i] f¨ ur i = 1, . . . , n (o.B.d.A. V = {1, . . . , n}).

Initialisierung:

B 1 [i] :=



 

 

d(s, i) , falls d(s, i) < ∞, i 6= s 0 , falls i = s

+∞ , sonst Iteration:

for k := 2 to n − 1 do for i := 1 to n do

B k [i] :=

0 , falls i = s

min j∈N

(i) {B k−1 [i], B k−1 [j] + d(j, i)} , sonst od

od

Bemerkung: N −1 (i) ist die Menge der Knoten, von denen aus eine Kante zu Knoten i f¨ uhrt.

Korrekheit:

klar (Beweis durch vollst¨ andige Induktion) Zeitbedarf:

Man beachte, dass in jedem Durchlauf der ¨ außeren Schleife jede Halbkante einmal ber¨ uhrt wird.

Satz 110

Der Zeitbedarf des Bellman-Ford-Algorithmus ist O(n · m).

Beweis:

s.o.

3. Floyd’s Algorithmus f¨ ur das all-pairs-shortest-path-Problem Dieser Algorithmus wird auch als

” Kleene’s Algorithmus“

bezeichnet. Er ist ein weiteres Beispiel f¨ ur dynamische Programmierung.

Sei G = (V, E) mit Distanzfunktion d : A → R + 0 gegeben. Sei o.B.d.A. V = {v 1 , . . . , v n }.

Wir setzen nun

c k ij := L¨ ange eines k¨ urzesten Pfades von v i nach v j , der als innere Knoten (alle bis auf ersten und letzten Knoten) nur Knoten aus {v 1 , . . . , v k } enth¨ alt.

algorithm floyd :=

for alle (i, j) do c (0) ij := d(i, j) od ; 1 ≤ i, j ≤ n for k := 1 to n do

for alle (i, j), 1 ≤ i, j ≤ n do c (k) ij := min

n

c (k−1) ij , c (k−1) ik + c (k−1) kj o od

od

Laufzeit: O(n 3 ) Korrektheit:

Zu zeigen: c (k) ij des Algorithmus = c k ij (damit sind die L¨ angen der k¨ urzesten Pfade durch c (n) ij gegeben).

Beweis:

Richtig f¨ ur k = 0. Induktionsschluss: Ein k¨ urzester Pfad von v i

Satz 111

Floyd’s Algorithmus f¨ ur das all-pairs-shortest-path-Problem hat Zeitkomplexit¨ at O(n 3 ).

4. Digraphen mit negativen Kantengewichten 4.1 Grunds¨ atzliches

Betrachte Startknoten s und einen Kreis C mit Gesamtl¨ ange < 0.

t t t t

t t

t t

t - - ppppppppp -

J J

J J ^ -

Q Q Q Q Q k

+ -

s

k 0

k 1 k 2

k 3 k 4

1 3 2 v

1 1

1

−5 1 C

dis[v] dis[v ⁰ ]

dis[v] dis[v ⁰ ] 6 H Y H H

v v ⁰ +∞

zweistufige Heaps: O(m + n · _{log log} ^log ^C _C )

Sei B _k [i] := L¨ ange eines k¨ urzesten Pfades von s zum Knoten i, wobei der Pfad h¨ ochstens k Kanten enth¨ alt.

B _k [i] :=

min _j∈N

_(i) {B k−1 [i], B k−1 [j] + d(j, i)} , sonst od

Bemerkung: N ⁻¹ (i) ist die Menge der Knoten, von denen aus eine Kante zu Knoten i f¨ uhrt.

Sei G = (V, E) mit Distanzfunktion d : A → R ⁺ ₀ gegeben. Sei o.B.d.A. V = {v ₁ , . . . , v n }.

c ^k _ij := L¨ ange eines k¨ urzesten Pfades von v i nach v j , der als innere Knoten (alle bis auf ersten und letzten Knoten) nur Knoten aus {v ₁ , . . . , v _k } enth¨ alt.

for alle (i, j) do c ⁽⁰⁾ _ij := d(i, j) od ; 1 ≤ i, j ≤ n for k := 1 to n do

for alle (i, j), 1 ≤ i, j ≤ n do c ^(k) _ij := min

c ^(k−1) _ij , c ^(k−1) _ik + c ^(k−1) _kj o od

Laufzeit: O(n ³ ) Korrektheit:

Zu zeigen: c ^(k) _ij des Algorithmus = c ^k _ij (damit sind die L¨ angen der k¨ urzesten Pfade durch c ⁽ⁿ⁾ _ij gegeben).

Floyd’s Algorithmus f¨ ur das all-pairs-shortest-path-Problem hat Zeitkomplexit¨ at O(n ³ ).

k ₀

k ₃ k 4

k ₁ k ₂

∀i ∈ V : B _n [i] ≥ B n−1 [i]

B _n [i] < B n−1 [i]

Man kann also in den Algorithmus von Bellman-Ford einen Test auf negative Kreise einbauen, indem man auch f¨ ur alle i ∈ V B _n [i]

if B _n [i] < B n−1 [i] then stop

? H H H H H Y 6 v ₁

v ₂

v ₃

v ₄ v 5

c ⁶ ₁₆ = 5 = c ⁵ ₁₆ c ⁶ ₆₁ = −6 = c ⁵ ₆₁

c ⁶ ₁₁ = min{c ⁵ ₁₁ , c ⁵ ₁₆ +c ⁵ ₆₁ } = −1

⇒ der Graph enth¨ alt einen negativen Kreis, gdw ein c ⁿ _ii < 0 existiert.

for i := 1 to n do if c ⁿ _ii < 0 then stop