Flussüberquerung (Missionare und Kannibalen)

11. Kürzeste Wege

Motivation, Universeller Algorithmus, Dijkstras Algorithmus auf Distanzgraphen,

[Ottman/Widmayer, Kap. 9.5.1-9.5.2 Cormen et al, Kap. 24.1-24.3]

Flusses. Ein dort bereitstehendes Boot fasst maximal zwei Personen. Zu keiner Zeit dürfen an einem Ort (Ufer oder Boot) mehr Kannibalen als Missionare sein. Wie kommen die Missionare und Kannibalen möglichst schnell über den Fluss?¹⁶

K K K

M M M

B

Formulierung als Graph

Zähle alle erlaubten Konfigurationen als Knoten auf und verbinde diese mit einer Kante, wenn Überfahrt möglich ist. Das Problem ist dann ein Problem des kürzesten Pfades

Beispiel

links rechts

Missionare 3 0

Kannibalen 3 0

Boot x

links rechts

Missionare 2 1

Kannibalen 2 1

Boot x

Überfahrt möglich

6Personen am linken Ufer 4Personen am linken Ufer

3 0 3 0 x

3 0 2 1 x

3 0 1 2 x

3 0 0 3 x

2 1 2 1 x

1 2 1 2 x

0 3 1 2 x

0 3 2 1 x

0 3 3 0 x

6 5 4 3 4 2 1 2 3

3 0 2 1 x

3 0 1 2 x

3 0 0 3 x

2 1 2 1 x

1 2 1 2 x

0 3 1 2 x

0 3 2 1 x

0 3 3 0 x

0 3 0 3 x

5 4 3 4 2 1 2 3 0

Anderes Beispiel: Schiebepuzzle

Wollen die schnelleste Lösung finden für 2 4 6

7 5 3 1 8

1 2 3 4 5 6 7 8

4 5 6 7 8

4 5 6

7 8

4 5 6 7 8

1 2 3 4 5 7 8 6

1 2 3

4 5

7 8 6

1 2 3 4 8 5

7 6

1 2 3 4 5 7 8 6

2 4 6 7 5 3 1 8

Routenfinder

Gegeben Städte A - Z und Distanzen zwischen den Städten.

A B

C D

E

F G

H

I Z

3

1 6

4 1 3

5

7 1

4 5

1

4 1

7 4

3 8

5

10 5

Was ist der kürzeste Weg von A nach Z?

Lösung: Breitensuche

S

t

Gewichtete Graphen

Gegeben:G= (V, E, c),c:E →R,s, t ∈V.

Gesucht: Länge (Gewicht) eines kürzesten Weges vonsnacht.

Weg:p=hs=v0, v1, . . . , vk =ti,(v_i, vi+1)∈E (0≤i < k) Gewicht:c(p) := ^Pk−1_i=0 c((v_i, v_i+1)).

S

2 1 t

3

2

1

Weg mit Gewicht9

Notation: Wir schreiben

u ^p v oder p:u v und meinen einen Wegpvonunachv

Notation: δ(u, v)= Gewicht eines kürzesten Weges vonunachv:

δ(u, v) =







∞ kein Weg vonunachv

min{c(p) :u ^p v} sonst

Beobachtungen (1)

Es gibt Situationen, in denen kein kürzester Weg existiert: negative Zyklen könnten auftreten.

s u

v

w 1 t

1

−1

−1 1

1

Es kann exponentiell viele Wege geben.

s

t (mindestens2^|V|/2 Wege von snacht)

⇒Alle Wege probieren ist zu ineffizient.

Beobachtungen (3)

Dreiecksungleichung Für alle s, u, v ∈V:

δ(s, v)≤δ(s, u) +δ(u, v)

s

u

v

Ein kürzester Weg vonsnachv(ohne weitere Einschränkungen) kann nicht länger sein als ein kürzester Weg vonsnachv, deruenthalten muss.

Optimale Substruktur

Teilpfade von kürzesten Pfaden sind kürzeste Pfade: Seip=hv₀, . . . , v_kiein kürzester Pfad vonv0 nachvk. Dann ist jeder der Teilpfadepij =hvi, . . . , vji (0≤i < j ≤k) ein kürzester Pfad vonv_i nachv_j.

u p x p y v

q

p

Wäre das nicht so, könnte man einen der Teilpfade kürzen, Widerspruch zur Voraussetzung.

Beobachtungen (5)

Kürzeste Wege enthalten keine Zyklen

1. Kürzester Weg enthält negativen Zyklus: es existiert kein kürzester Weg.

Widerspruch.

2. Weg enthält positiven Zyklus: Weglassen des positiven Zyklus kann den Weg verkürzen: Widerspruch

3. Weg enthält Zyklus vom Gewicht0: Weglassen des Zyklus verändert das Pfadgewicht nicht. Weglassen (Konvention).

Gesucht: Kürzeste Wege von einem Startknotensaus.

Gewicht des kürzesten bisher gefundenen Pfades ds:V →R

Zu Beginn:d_s[v] =∞für alle Knotenv ∈V. Ziel: d_s[v] =δ(s, v)für allev ∈V.

Vorgänger eines Knotens

π_s :V →V

Zu Beginnπ_s[v]undefiniert für jeden Knotenv ∈V

Allgemeiner Algorithmus

1. Initialisiered_s undπ_s:d_s[v] =∞,π_s[v] =null für allev ∈V 2. Setzed_s[s]←0

3. Wähle eine Kante(u, v)∈E Relaxiere(u, v):

ifd_s[v]> d_s[u] +c(u, v)then ds[v]←ds[u] +c(u, v) π_s[v]←u

4. Wiederhole 3 bis nichts mehr relaxiert werden kann.

(bisd_s[v]≤d_s[u] +c(u, v) ∀(u, v)∈E)

Relaxieren ist sicher

Zu jeder Zeit gilt in obigem Algorithmus

d_s[v]≥δ(s, v) ∀v ∈V

δ(s, u)≤d_s[u] [Induktionsvorraussetzung].

δ(u, v)≤c(u, v) [Minimalität vonδ]

⇒ ds[u] +c(u, v)≥δ(s, v)

⇒min{d_s[v], ds[u] +c(u, v)} ≥δ(s, v)

Relaxieren ist sicher

Zu jeder Zeit gilt in obigem Algorithmus

d_s[v]≥δ(s, v) ∀v ∈V Im Relaxierschritt:

δ(s, v)≤δ(s, u) +δ(u, v) [Dreiecksungleichung].

δ(s, u)≤d_s[u] [Induktionsvorraussetzung].

δ(u, v)≤c(u, v) [Minimalität vonδ]

⇒ ds[u] +c(u, v)≥δ(s, v)

⇒min{d_s[v], ds[u] +c(u, v)} ≥δ(s, v)

Wie / in welcher Reihenfolge wählt man die Kanten in obigem Algorithmus?

Spezialfalfall: Gerichteter Azyklischer Graph (DAG)

DAG⇒Topologische Sortierung liefert optimale Besuchsreihenfolge

s

v₁

v₂

v3

v₄

v₅

v6

v₇ v₈ 2

4

−3

1

−1

2

−2

2

−2 2

3

−1

0

2

4

−1

−2

0

−4

3

−6

Top. Sortieren:⇒Reihenfolges, v₁, v₂, v₃, v₄, v₆, v₅, v₈, v₇.

s

v₁

v₂

v3

v₄

v₅

v6

v₇ v₈ 2

4

−3

1

−1

2

−2

2

−2 2

3

−1 0

2

4

−1

−2

0

−4

3

−6

Annahme (vorübergehend)

s

a

b

c

d

e 2

3 2

6

1

3

1

1

Alle Gewichte von Gsindpositiv.

s

u

v

w 4

7

2

t 0

4

7

2

obere Schranken

kleinste obere Schranke globales Minimum!

Kann nicht weiter relaxiert werden

Grundidee

MengeV aller Knoten wird unterteilt in die MengeM von Knoten, für die schon ein kürzester Weg vonsbekannt ist die MengeR=^S_v∈MN⁺(v)\M von Knoten, für die kein kürzester Weg bekannt ist, die jedoch vonM direkt erreichbar sind.

die MengeU =V \(M ∪R)von Knoten, die noch nicht berücksichtigt wurden.

s 2 2 5

3

5

2 1

2

Induktion über|M|: Wähle Knoten ausRmit kleinster oberer Schranke. Nimm r zu M hinzu, und updateRundU.

Korrektheit: Ist innerhalb einer “Wellen- front” einmal ein Knoten mit minimalem Pfadgewichtwgefunden, kann kein Pfad über später gefundene Knoten (mit Gewicht ≥ w) zu einer Verbesserung führen.

s 2 2 5

3

5

2 1

2

Algorithmus Dijkstra(G, s)

Input: Positiv gewichteter Graph G= (V, E, c), Startpunkt s∈V

Output: Minimale Gewichtedder k¨urzesten Pfade und Vorg¨angerknoten f¨ur jeden Knoten.

foreachu∈V do

ds[u]← ∞;πs[u]←null d_s[s]←0;R← {s}

whileR 6=∅do

u← ExtractMin(R) foreach v∈N⁺(u) do

if d_s[u] +c(u, v)< d_s[v]then ds[v]←ds[u] +c(u, v) πs[v]←u

R←R∪ {v}

s

a

b

c

d

e 2

3 2

6

1

3

1

1

Beispiel

s

a

b

c

d

e 2

3 2

6

1

3

1

1

0

∞

∞

∞

∞

∞

s

M ={s}

R ={}

U ={a, b, c, d, e}

s

a

b

c

d

e 2

3 2

6

1

3

1

1

0

∞

∞

∞

∞

∞

ss

a

b

2

3

M ={s}

R={a, b}

U ={c, d, e}

Beispiel

s

a

b

c

d

e 2

3 2

6

1

3

1

1

0

∞

∞

∞

∞

∞

ss

a

b

2

3

a c

8

M ={s, a}

R={b, c}

U ={d, e}

s

a

b

c

d

e 2

3 2

6

1

3

1

1

0

∞

∞

∞

∞

∞

ss

a

b

2

3

a c

8

b d

4

M ={s, a, b}

R={c, d}

U ={e}

Beispiel

s

a

b

c

d

e 2

3 2

6

1

3

1

1

0

∞

∞

∞

∞

∞

ss

a

b

2

3

a c

8

b d

4

d

e

5 7

M ={s, a, b, d}

R ={c, e}

U ={}

s

a

b

c

d

e 2

3 2

6

1

3

1

1

0

∞

∞

∞

∞

∞

ss

a

b

2

3

a c

8

b d

4

d

e

5 7

e

6

M ={s, a, b, d, e}

R ={c}

U ={}

Beispiel

s

a

b

c

d

e 2

3 2

6

1

3

1

1

0

∞

∞

∞

∞

∞

ss

a

b

2

3

a c

8

b d

4

d

e

5 7

e

6

c

M ={s, a, b, d, e, c}

R ={}

U ={}

Zur Implementation: Datenstruktur für R?

Benötigte Operationen:

Insert (Hinzunehmen zuR)

ExtractMin (überR) und DecreaseKey (Update inR) foreachv∈N⁺(u) do

if d_s[u] +c(u, v)< d_s[v]then ds[v]←ds[u] +c(u, v) πs[v]←u

if v∈R then

DecreaseKey(R, v) // Update einesd(v)im Heap zu R else

R ←R∪ {v} // Einf¨ugen eines neuen d(v)im Heap zu R

Zur Implementation: Datenstruktur für R?

Benötigte Operationen:

Insert (Hinzunehmen zuR)

ExtractMin (überR) und DecreaseKey (Update inR) foreachv∈N⁺(u) do

if d_s[u] +c(u, v)< d_s[v]then ds[v]←ds[u] +c(u, v) πs[v]←u

if v∈R then

DecreaseKey(R, v) // Update einesd(v)im Heap zu R else

R ←R∪ {v} // Einf¨ugen eines neuen d(v)im Heap zu R

MinHeap!

DecreaseKey

DecreaseKey: Aufsteigen im MinHeap inO(log|V|)

Problem: Position im Heap unbekannt.

Kompliziert: die Position der Knoten im Heap ändert sich oft, dann muss die Information nachgeführt werden.

DecreaseKey

DecreaseKey: Aufsteigen im MinHeap inO(log|V|) Problem: Position im Heap unbekannt.

→ Speichern der Position am Knoten (in-place) oder in einer Hashtabelle (extern)

Kompliziert: die Position der Knoten im Heap ändert sich oft, dann muss die Information nachgeführt werden.

DecreaseKey

DecreaseKey: Aufsteigen im MinHeap inO(log|V|) Problem: Position im Heap unbekannt.

→ Speichern der Position am Knoten (in-place) oder in einer Hashtabelle (extern)

DecreaseKey

DecreaseKey: Aufsteigen im MinHeap inO(log|V|) Problem: Position im Heap unbekannt.

→ Speichern der Position am Knoten (in-place) oder in einer Hashtabelle (extern)

Kompliziert: die Position der Knoten im Heap ändert sich oft, dann muss die Information nachgeführt werden.

Lösung: Vermeiden von DecreaseKey

→ Knoten nach erfolgreichem Relaxieren erneut einfügen. Knoten beim Entnehmen als "deleted" kennzeichnen(Lazy Deletion)

(Kein so grosser) Nachteil: Speicherbedarf vom Heap wächst bis zuΘ(|E|).

Da|E| ≤ |V|², Laufzeiten der Operationen Insert und ExtractMin aber auch in

O(log|V|²) =O(log|V|).

Laufzeit von Dijkstra

|V|×ExtractMin:O(|V|log|V|)

|E|×Insert oder DecreaseKey:O(|E|log|V|) 1×Init: O(|V|)

Insgesamt^{17 18} :

O((|V|+|E|) log|V|)

17Für zusammenhängende Graphen:O(|E|log|V|)

18Kann verbessert werden unter Verwendung einer für ExtractMin und DecreaseKey optimierten Datenstruktur (Fibonacci Heap), dann Laufzeit O(|E|+|V|log|V|).

Motivation A*

s

t

0 1

1 1

1

2 2

2 2

2 2

2

3 3

3 3

3 3

3 3 4

4 4

4 4

4 4

4 4

4 4

4

Algorithmus von Dijkstra sucht die kürzesten Wege zu allen Knoten, in alle Richtungen

Motivation A*

s

t 0

1

1 1

1

2 2

2 2

2 2

3

3 3

3 3 4

4 4

4

Algorithmus von Dijkstra sucht die kürzesten Wege zu allen Knoten, in alle Richtungen

Motivation A*

s

t 0

1

1 1

1

2 2

2 2

2 2

2

3 3

3 3

3 3

3 3 4

4 4

4 4

4 4

4 4

4 4

4

Algorithmus von Dijkstra sucht die kürzesten Wege zu allen Knoten, in alle Richtungen

Motivation A*

s

t 0

1

1 1

1

2 2

2 2

2 2

2

3

3 3

3 3 4

4 4

4

Algorithmus von Dijkstra sucht die kürzesten Wege zu allen Knoten, in alle Richtungen

Motivation A*

s

t 0

1

1 1

1

2 2

2 2

2 2

2

3 3

3 3

3 3

3 3

4

4 4

4 4

4 4

4 4

4 4

4

Algorithmus von Dijkstra sucht die kürzesten Wege zu allen Knoten, in alle Richtungen

Motivation A*

s

t 0

1

1 1

1

2 2

2 2

2 2

2

3 3

3 3

3 3

3 3 4

4 4

4 4

4

4

4

Algorithmus von Dijkstra sucht die kürzesten Wege zu allen Knoten, in alle Richtungen

Motivation A*

s

t 0

1

1 1

1

2 2

2 2

2 2

2

3 3

3 3

3 3

3 3 4

4 4

4 4

4 4

4 4

4 4

4

Algorithmus von Dijkstra sucht die kürzesten Wege zu allen Knoten, in alle Richtungen

Motivation A*

s

t

0 1

1 1

1

2 2

2 2

2 2

3

3 3

3 6 7 8

Algorithmus von Dijkstra sucht die kürzesten Wege zu allen Knoten, in alle Richtungen

was richtig ist, da die Stuktur des Graphen dem Algorithmus nicht bekannt ist

Motivation A*

s

t 0

1

1 1

1

2 2

2 2

2 2

2

3 3

3 3

3 3

3 4

4 4

4

5 5

5 6

6 7 8

Algorithmus von Dijkstra sucht die kürzesten Wege zu allen Knoten, in alle Richtungen

was richtig ist, da die Stuktur des Graphen dem Algorithmus nicht bekannt ist

Motivation A*

s

t 0

1

1 1

1

2 2

2 2

2 2

3

3 3

3 6 7 8

Algorithmus von Dijkstra sucht die kürzesten Wege zu allen Knoten, in alle Richtungen

was richtig ist, da die Stuktur des Graphen dem Algorithmus nicht bekannt ist

Motivation A*

s

t 0

1

1 1

1

2 2

2 2

2 2

2

3 3

3 3

3 3

3 4

4 4

4

5 5

5 6

6 7 8

Algorithmus von Dijkstra sucht die kürzesten Wege zu allen Knoten, in alle Richtungen

was richtig ist, da die Stuktur des Graphen dem Algorithmus nicht bekannt ist

Motivation A*

s

t 0

1

1 1

1

2 2

2 2

2 2

2

3 3

3 3

3 3

3

6 7 8

Algorithmus von Dijkstra sucht die kürzesten Wege zu allen Knoten, in alle Richtungen

was richtig ist, da die Stuktur des Graphen dem Algorithmus nicht bekannt ist

Motivation A*

s

t 0

1

1 1

1

2 2

2 2

2 2

2

3 3

3 3

3 3

3 4

4 4

4

5 5

5 6

6 7 8

Algorithmus von Dijkstra sucht die kürzesten Wege zu allen Knoten, in alle Richtungen

was richtig ist, da die Stuktur des Graphen dem Algorithmus nicht bekannt ist

Motivation A*

s

t 0

1

1 1

1

2 2

2 2

2 2

2

3 3

3 3

3 3

3 4

4 4

4

5 5

5

6 7 8

Algorithmus von Dijkstra sucht die kürzesten Wege zu allen Knoten, in alle Richtungen

was richtig ist, da die Stuktur des Graphen dem Algorithmus nicht bekannt ist

Motivation A*

s

t 0

1

1 1

1

2 2

2 2

2 2

2

3 3

3 3

3 3

3 4

4 4

4

5 5

5 6

6

7 8

Algorithmus von Dijkstra sucht die kürzesten Wege zu allen Knoten, in alle Richtungen

was richtig ist, da die Stuktur des Graphen dem Algorithmus nicht bekannt ist

Motivation A*

s

t 0

1

1 1

1

2 2

2 2

2 2

2

3 3

3 3

3 3

3 4

4 4

4

5 5

5 6

6 7

Algorithmus von Dijkstra sucht die kürzesten Wege zu allen Knoten, in alle Richtungen

was richtig ist, da die Stuktur des Graphen dem Algorithmus nicht bekannt ist

Motivation A*

s

t 0

1

1 1

1

2 2

2 2

2 2

2

3 3

3 3

3 3

3 4

4 4

4

5 5

5 6

6 7 8

Algorithmus von Dijkstra sucht die kürzesten Wege zu allen Knoten, in alle Richtungen

was richtig ist, da die Stuktur des Graphen dem Algorithmus nicht bekannt ist

A* in Action

f(u) =ˆ d_s[u]+ˆh(u) (ˆh=δ_x+δ_y Manhattan-Distanz)

s

t

5 4 3 2 1 0

6 5 4 3 2 1

7 6 5 4 3 2

8 7 6 5 4 3

0 4

1 4 1 6

1 4 1 6

2 6

2 4

2 4 2 6

3 4 3 6

3 8 2 8

2 8

2 3 4

3 10

3 5

6 8

7 8

8 8

Idee: führe den Algorithmus in eine bevorzugte Richtung mit Hilfe einer Abstandsheuristikhˆ Der Wert dieser Heuristik muss den wahren Abstand zu t unterschätzen und wird zum gefundenen Abstandd_szus addiert.

A* in Action

f(u) =ˆ d_s[u]+ˆh(u) (ˆh=δ_x+δ_y Manhattan-Distanz)

s

5 4 3 2 1 0t

6 5 4 3 2 1

7 6 5 4 3 2

8 7 6 5 4 3

9 8 7 6 5 4

0 4

1 4 1 6

1 4 1 6

2 6

2 4

2 4 2 6

3 4 3 6

3 8 2 8

2 8

2 8

3 8

4 8

3 10

3 10

3 10

4 10

5 10

5 8

6 8

7 8

8 8

Idee: führe den Algorithmus in eine bevorzugte Richtung mit Hilfe einer Abstandsheuristikhˆ Der Wert dieser Heuristik muss den wahren Abstand zu t unterschätzen und wird zum gefundenen Abstandd_szus addiert.

A* in Action

f(u) =ˆ d_s[u]+ˆh(u) (ˆh=δ_x+δ_y Manhattan-Distanz)

s

5 4 3 2 1 0t

6 5 4 3 2 1

7 6 5 4 3 2

8 7 6 5 4 3

9 8 7 6 5 4

0 4

1 4 1 6

1 4 1 6

2 6

2 4

2 4 2 6

3 4 3 6

3 8 2 8

2 8

2 3 4

3 10

3 5

6 8

7 8

8 8

Idee: führe den Algorithmus in eine bevorzugte Richtung mit Hilfe einer Abstandsheuristikhˆ Der Wert dieser Heuristik muss den wahren Abstand zu t unterschätzen und wird zum gefundenen Abstandd_szus addiert.

A* in Action

f(u) =ˆ d_s[u]+ˆh(u) (ˆh=δ_x+δ_y Manhattan-Distanz)

s

5 4 3 2 1 0t

6 5 4 3 2 1

7 6 5 4 3 2

8 7 6 5 4 3

9 8 7 6 5 4

0 4

1 4 1 6

1 4 1 6

2 6

2 4

2 4 2 6

3 4 3 6

3 8 2 8

2 8

2 8

3 8

4 8

3 10

3 10

3 10

4 10

5 10

5 8

6 8

7 8

8 8

Idee: führe den Algorithmus in eine bevorzugte Richtung mit Hilfe einer Abstandsheuristikhˆ Der Wert dieser Heuristik muss den wahren Abstand zu t unterschätzen und wird zum gefundenen Abstandd_szus addiert.

A* in Action

f(u) =ˆ d_s[u]+ˆh(u) (ˆh=δ_x+δ_y Manhattan-Distanz)

s

5 4 3 2 1 0t

6 5 4 3 2 1

7 6 5 4 3 2

8 7 6 5 4 3

9 8 7 6 5 4

0 4

1 4 1 6

1 4 1 6

2 6

2 4

2 4 2 6

3 4 3 6

3 8 2 8

2 8

2 3 4

3 10

3 5

6 8

7 8

8 8

Idee: führe den Algorithmus in eine bevorzugte Richtung mit Hilfe einer Abstandsheuristikhˆ Der Wert dieser Heuristik muss den wahren Abstand zu t unterschätzen und wird zum gefundenen Abstandd_szus addiert.

A* in Action

f(u) =ˆ d_s[u]+ˆh(u) (ˆh=δ_x+δ_y Manhattan-Distanz)

s

5 4 3 2 1 0t

6 5 4 3 2 1

7 6 5 4 3 2

8 7 6 5 4 3

9 8 7 6 5 4

0 4

1 4 1 6

1 4 1 6

2 6

2 4

2 4 2 6

3 4 3 6

3 8 2 8

2 8

2 8

3 8

4 8

3 10

3 10

3 10

4 10

5 10

5 8

6 8

7 8

8 8

Idee: führe den Algorithmus in eine bevorzugte Richtung mit Hilfe einer Abstandsheuristikhˆ Der Wert dieser Heuristik muss den wahren Abstand zu t unterschätzen und wird zum gefundenen Abstandd_szus addiert.

A* in Action

f(u) =ˆ d_s[u]+ˆh(u) (ˆh=δ_x+δ_y Manhattan-Distanz)

s

5 4 3 2 1 0t

6 5 4 3 2 1

7 6 5 4 3 2

8 7 6 5 4 3

9 8 7 6 5 4

0 4

1 4 1 6

1 4 1 6

2 6

2 4

2 4 2 6

3 4 3 6

3 8 2 8

2 8

2 8

3 8

4 8

3 10

3 5

6 8

7 8

8 8

Idee: führe den Algorithmus in eine bevorzugte Richtung mit Hilfe einer Abstandsheuristikhˆ Der Wert dieser Heuristik muss den wahren Abstand zu t unterschätzen und wird zum gefundenen Abstandd_szus addiert.

A* in Action

f(u) =ˆ d_s[u]+ˆh(u) (ˆh=δ_x+δ_y Manhattan-Distanz)

s

5 4 3 2 1 0t

6 5 4 3 2 1

7 6 5 4 3 2

8 7 6 5 4 3

9 8 7 6 5 4

0 4

1 4 1 6

1 4 1 6

2 6

2 4

2 4 2 6

3 4 3 6

3 8 2 8

2 8

2 8

3 8

4 8

3 10

3 10

3 10

4 10

5 10

5 8

6 8

7 8

8 8

Idee: führe den Algorithmus in eine bevorzugte Richtung mit Hilfe einer Abstandsheuristikhˆ Der Wert dieser Heuristik muss den wahren Abstand zu t unterschätzen und wird zum gefundenen Abstandd_szus addiert.

A* in Action

f(u) =ˆ d_s[u]+ˆh(u) (ˆh=δ_x+δ_y Manhattan-Distanz)

s

5 4 3 2 1 0t

6 5 4 3 2 1

7 6 5 4 3 2

8 7 6 5 4 3

9 8 7 6 5 4

0 4

1 4 1 6

1 4 1 6

2 6

2 4

2 4 2 6

3 4 3 6

3 8 2 8

2 8

2 8

3 8

4 8

3 10

3 10

3 10

4 10

5 10

5 8

6 8

8

Idee: führe den Algorithmus in eine bevorzugte Richtung mit Hilfe einer Abstandsheuristikhˆ Der Wert dieser Heuristik muss den wahren Abstand zu t unterschätzen und wird zum gefundenen Abstandd_szus addiert.

A* in Action

f(u) =ˆ d_s[u]+ˆh(u) (ˆh=δ_x+δ_y Manhattan-Distanz)

s

5 4 3 2 1 0t

6 5 4 3 2 1

7 6 5 4 3 2

8 7 6 5 4 3

9 8 7 6 5 4

0 4

1 4 1 6

1 4 1 6

2 6

2 4

2 4 2 6

3 4 3 6

3 8 2 8

2 8

2 8

3 8

4 8

3 10

3 10

3 10

4 10

5 10

5 8

6 8

7 8

8 8

Idee: führe den Algorithmus in eine bevorzugte Richtung mit Hilfe einer Abstandsheuristikhˆ Der Wert dieser Heuristik muss den wahren Abstand zu t unterschätzen und wird zum gefundenen Abstandd_szus addiert.

Weg zurückverfolgen

f(u) =ˆ d_s[u]+ˆh(u) (ˆh=δ_x+δ_y)

s

t

4 3 2 1 0

5 4 3 2 1

6 5 4 3 2

7 1 6 0 5 1 4 3 1

6

2 2

8

2 6

2 6

3 6

3 6

3 6 3 8

4 6

4 6 4

8

5 6

6 6

Der Algorithmus funktioniert genauso wie der

Dijkstra-Algorithmus.

Anstelle des Wertes vond_s tritt für das Suchen des nächsten

Elements inR der Wert von fˆ= ˆh+d_s

Weg zurückverfolgen

f(u) =ˆ d_s[u]+ˆh(u) (ˆh=δ_x+δ_y)

s

4 3 2 1 0t

5 4 3 2 1

6 5 4 3 2

7 6 5 4 3

8 7 6 5 4

0 6 1 8

1 6 1 8

1 6

2 6

2 8

2 6

2 6

2 8

3 6

3 6

3 8

3 6 3 8

4 6

4 6 4

8

5 6

6 6

Der Algorithmus funktioniert genauso wie der

Dijkstra-Algorithmus.

Anstelle des Wertes vond_s tritt für das Suchen des nächsten

Elements inR der Wert von fˆ= ˆh+d_s

Weg zurückverfolgen

f(u) =ˆ d_s[u]+ˆh(u) (ˆh=δ_x+δ_y)

s

4 3 2 1 0t

5 4 3 2 1

6 5 4 3 2

7 6 5 4 3

8 7 6 5 4

0 6

1 1

1 6

2 2

8

2 6

2 6

3 6

3 6

3 6 3 8

4 6

4 6 4

8

5 6

6 6

Der Algorithmus funktioniert genauso wie der

Dijkstra-Algorithmus.

Anstelle des Wertes vond_s tritt für das Suchen des nächsten

Elements inR der Wert von fˆ= ˆh+d_s

Weg zurückverfolgen

f(u) =ˆ d_s[u]+ˆh(u) (ˆh=δ_x+δ_y)

s

4 3 2 1 0t

5 4 3 2 1

6 5 4 3 2

7 6 5 4 3

8 7 6 5 4

0 6 1 8

1 6 1 8

1 6

2 6

2 8

2 6

2 6

2 8

3 6

3 6

3 8

3 6 3 8

4 6

4 6 4

8

5 6

6 6

Der Algorithmus funktioniert genauso wie der

Dijkstra-Algorithmus.

Anstelle des Wertes vond_s tritt für das Suchen des nächsten

Elements inR der Wert von fˆ= ˆh+d_s

Weg zurückverfolgen

f(u) =ˆ d_s[u]+ˆh(u) (ˆh=δ_x+δ_y)

s

4 3 2 1 0t

5 4 3 2 1

6 5 4 3 2

7 6 5 4 3

8 7 6 5 4

0 6 1 8

1 6 1 8

1 6

2 6

2 8

2 6

2 6

2 8

3 6

3 6

3 6 3 8

4 6

4 6 4

8

5 6

6 6

Der Algorithmus funktioniert genauso wie der

Dijkstra-Algorithmus.

Anstelle des Wertes vond_s tritt für das Suchen des nächsten

Elements inR der Wert von fˆ= ˆh+d_s

Weg zurückverfolgen

f(u) =ˆ d_s[u]+ˆh(u) (ˆh=δ_x+δ_y)

s

4 3 2 1 0t

5 4 3 2 1

6 5 4 3 2

7 6 5 4 3

8 7 6 5 4

0 6 1 8

1 6 1 8

1 6

2 6

2 8

2 6

2 6

2 8

3 6

3 6

3 8

3 6 3 8

4 6

4 6 4

8

5 6

6 6

Der Algorithmus funktioniert genauso wie der

Dijkstra-Algorithmus.

Anstelle des Wertes vond_s tritt für das Suchen des nächsten

Elements inR der Wert von fˆ= ˆh+d_s

Weg zurückverfolgen

f(u) =ˆ d_s[u]+ˆh(u) (ˆh=δ_x+δ_y)

s

4 3 2 1 0t

5 4 3 2 1

6 5 4 3 2

7 6 5 4 3

8 7 6 5 4

0 6 1 8

1 6 1 8

1 6

2 6

2 8

2 6

2 6

2 8

3 6

3 6

3 8

3 6 3 8

4 6

4 6 4

8

Der Algorithmus funktioniert genauso wie der

Dijkstra-Algorithmus.

Anstelle des Wertes vond_s tritt für das Suchen des nächsten

Elements inR der Wert von fˆ= ˆh+d_s

Weg zurückverfolgen

f(u) =ˆ d_s[u]+ˆh(u) (ˆh=δ_x+δ_y)

s

4 3 2 1 0t

5 4 3 2 1

6 5 4 3 2

7 6 5 4 3

8 7 6 5 4

0 6 1 8

1 6 1 8

1 6

2 6

2 8

2 6

2 6

2 8

3 6

3 6

3 8

3 6 3 8

4 6

4 6 4

8

5 6

6 6

Der Algorithmus funktioniert genauso wie der

Dijkstra-Algorithmus.

Anstelle des Wertes vond_s tritt für das Suchen des nächsten

Elements inR der Wert von fˆ= ˆh+d_s

f(u) =ˆ d_s[u]+ˆh(u) (ˆh=δ_x+δ_y)

s

4 3 2 1 0t

5 4 3 2 1

6 5 4 3 2

7 6 5 4 3

8 7 6 5 4

0 6 1 8

1 6 1 8

1 6

2 6

2 8

2 6

2 6

2 8

3 6

3 6

3 8

3 6 3 8

4 6

4 6 4

8

5 6

6 6

Der Algorithmus funktioniert genauso wie der

Dijkstra-Algorithmus.

Anstelle des Wertes vond_s tritt für das Suchen des nächsten

Elements inR der Wert von fˆ= ˆh+d_s

Weg zurückverfolgen

f(u) =ˆ d_s[u]+ˆh(u) (ˆh=δ_x+δ_y)

s

4 3 2 1 0t

5 4 3 2 1

6 5 4 3 2

7 6 5 4 3

8 7 6 5 4

0 6 1 8

1 6 1 8

1 6

2 6

2 8

2 6

2 6

2 8

3 6

3 6

3 8

3 6 3 8

4 6

4 6 4

8

5 6

6 6

Der Algorithmus funktioniert genauso wie der

Dijkstra-Algorithmus.

Anstelle des Wertes vond_s tritt für das Suchen des nächsten

Elements inR der Wert von fˆ= ˆh+d_s

Voraussetzungen

Positiv gewichteter, endlicher GraphG= (V, E, c) s∈V,t∈V

Abstandsschätzungh^b_t(v)≤h_t(v) :=δ(v, t)∀v ∈V. Gesucht: kürzester Pfad p:s t

A*-Algorithmus(G, s, t, h) ˆ

Input: Positiv gewichteter Graph G= (V, E, c), Startpunkt s∈V, Endpunkt t∈V, Sch¨atzung ^bh(v)≤δ(v, t)

Output: Existenz und Wert eines k¨urzesten Pfades vonsnach t foreachu∈V do

d[u]← ∞;fb[u]← ∞;π[u]←null d[s]←0;f[s]^b ←bh(s);R ← {s};M ← {}

whileR 6=∅do u← ExtractMin

fb(R);M ←M ∪ {u}

if u=tthen return success

foreach v∈N⁺(u) with d[v]> d[u] +c(u, v) do d[v]←d[u] +c(u, v);f^b[v]←d[v] +^bh(v);π[v]←u R←R∪ {v};M ←M− {v}

returnfailure

Was, wenn h ˆ nicht unterschätzt

f(u) =ˆ d_s[u]+ˆh(u) (ˆh=δ²_x+δ_y²)

s

t

16 9 4 1 0

17 10 5 2 1

20 13 8 5 4

25 118 013 110 9 1

14

2 2 10

3 13

3 8 4 14

4 6

5 14 5 22

6 22

6 10 5 14

6 10

7 8

8 8 6

22

Algorithmus kann mit dem falschen Resultat terminieren, wennˆhdie Distanz zutnicht unterschätzt.

obwohl die Heuristik ansonsten vernünftig aussieht (sie ist z.B.

monoton)

Was, wenn h ˆ nicht unterschätzt

f(u) =ˆ d_s[u]+ˆh(u) (ˆh=δ²_x+δ_y²)

s

16 9 4 1 0t

17 10 5 2 1

20 13 8 5 4

25 18 13 10 9 32 25 20 17 16

0 18 1 26

1 14 1 26

1 14

2 12

2 10

2 22

3 13

3 8 4 14

4 6 3 20

5 14 5 22

6 22

6 10 5 14

6 10

7 8

8 8 6

22

Algorithmus kann mit dem falschen Resultat terminieren, wennˆhdie Distanz zutnicht unterschätzt.

obwohl die Heuristik ansonsten vernünftig aussieht (sie ist z.B.

monoton)

Was, wenn h ˆ nicht unterschätzt

f(u) =ˆ d_s[u]+ˆh(u) (ˆh=δ²_x+δ_y²)

s

16 9 4 1 0t

17 10 5 2 1

20 13 8 5 4

25 18 13 10 9 32 25 20 17 16

0 18

1 1

1 14

2 2 10

3 13

3 8 4 14

4 6

5 14 5 22

6 22

6 10 5 14

6 10

7 8

8 8 6

22

Algorithmus kann mit dem falschen Resultat terminieren, wennˆhdie Distanz zutnicht unterschätzt.

obwohl die Heuristik ansonsten vernünftig aussieht (sie ist z.B.

monoton)

Was, wenn h ˆ nicht unterschätzt

f(u) =ˆ d_s[u]+ˆh(u) (ˆh=δ²_x+δ_y²)

s

16 9 4 1 0t

17 10 5 2 1

20 13 8 5 4

25 18 13 10 9 32 25 20 17 16

0 18 1 26

1 14 1 26

1 14

2 12

2 10

2 22

3 13

3 8 4 14

4 6 3 20

5 14 5 22

6 22

6 10 5 14

6 10

7 8

8 8 6

22

Algorithmus kann mit dem falschen Resultat terminieren, wennˆhdie Distanz zutnicht unterschätzt.

obwohl die Heuristik ansonsten vernünftig aussieht (sie ist z.B.

monoton)

Was, wenn h ˆ nicht unterschätzt

f(u) =ˆ d_s[u]+ˆh(u) (ˆh=δ²_x+δ_y²)

s

16 9 4 1 0t

17 10 5 2 1

20 13 8 5 4

25 18 13 10 9 32 25 20 17 16

0 18 1 26

1 14 1 26

1 14

2 12

2 10

2 22

3 13

3 8 4 14

4 6

5 14 5 22

6 22

6 10 5 14

6 10

7 8

8 8 6

22

Algorithmus kann mit dem falschen Resultat terminieren, wennˆhdie Distanz zutnicht unterschätzt.

obwohl die Heuristik ansonsten vernünftig aussieht (sie ist z.B.

monoton)

Was, wenn h ˆ nicht unterschätzt

f(u) =ˆ d_s[u]+ˆh(u) (ˆh=δ²_x+δ_y²)

s

16 9 4 1 0t

17 10 5 2 1

20 13 8 5 4

25 18 13 10 9 32 25 20 17 16

0 18 1 26

1 14 1 26

1 14

2 12

2 10

2 22

3 13

3 8

4 14

4 6 3 20

5 14 5 22

6 22

6 10 5 14

6 10

7 8

8 8 6

22

Algorithmus kann mit dem falschen Resultat terminieren, wennˆhdie Distanz zutnicht unterschätzt.

obwohl die Heuristik ansonsten vernünftig aussieht (sie ist z.B.

monoton)

Was, wenn h ˆ nicht unterschätzt

f(u) =ˆ d_s[u]+ˆh(u) (ˆh=δ²_x+δ_y²)

s

16 9 4 1 0t

17 10 5 2 1

20 13 8 5 4

25 18 13 10 9 32 25 20 17 16

0 18 1 26

1 14 1 26

1 14

2 12

2 10

2 22

3 13

3 8 4 14

4 6

5 14 5 22

6 22

6 10 5 14

6 10

7 8

8 8 6

22

Algorithmus kann mit dem falschen Resultat terminieren, wennˆhdie Distanz zutnicht unterschätzt.

obwohl die Heuristik ansonsten vernünftig aussieht (sie ist z.B.

monoton)

Was, wenn h ˆ nicht unterschätzt

f(u) =ˆ d_s[u]+ˆh(u) (ˆh=δ²_x+δ_y²)

s

16 9 4 1 0t

17 10 5 2 1

20 13 8 5 4

25 18 13 10 9 32 25 20 17 16

0 18 1 26

1 14 1 26

1 14

2 12

2 10

2 22

3 13

3 8 4 14

4 6 3 20

5 14 5 22

6 22

6 10 5 14

6 10

7 8

8 8 6

22

Algorithmus kann mit dem falschen Resultat terminieren, wennˆhdie Distanz zutnicht unterschätzt.

obwohl die Heuristik ansonsten vernünftig aussieht (sie ist z.B.

monoton)

Was, wenn h ˆ nicht unterschätzt

f(u) =ˆ d_s[u]+ˆh(u) (ˆh=δ²_x+δ_y²)

s

16 9 4 1 0t

17 10 5 2 1

20 13 8 5 4

25 18 13 10 9 32 25 20 17 16

0 18 1 26

1 14 1 26

1 14

2 12

2 10

2 22

3 13

3 8 4 14

4 6 3 20

5 14 5 22

Algorithmus kann mit dem falschen Resultat terminieren, wennˆhdie Distanz zutnicht unterschätzt.

obwohl die Heuristik ansonsten vernünftig aussieht (sie ist z.B.

monoton)

Was, wenn h ˆ nicht unterschätzt

f(u) =ˆ d_s[u]+ˆh(u) (ˆh=δ²_x+δ_y²)

s

16 9 4 1 0t

17 10 5 2 1

20 13 8 5 4

25 18 13 10 9 32 25 20 17 16

0 18 1 26

1 14 1 26

1 14

2 12

2 10

2 22

3 13

3 8 4 14

4 6 3 20

5 14 5 22

6 22

6 10

5 14

6 10

7 8

8 8 6

22

Algorithmus kann mit dem falschen Resultat terminieren, wennˆhdie Distanz zutnicht unterschätzt.

obwohl die Heuristik ansonsten vernünftig aussieht (sie ist z.B.

monoton)

f(u) =ˆ d_s[u]+ˆh(u) (ˆh=δ_x+δ_y)

s

16 9 4 1 0t

17 10 5 2 1

20 13 8 5 4

25 18 13 10 9 32 25 20 17 16

0 18 1 26

1 14 1 26

1 14

2 12

2 10

2 22

3 13

3 8 4 14

4 6 3 20

5 14 5 22

6 22

6 10 5 14

6 10

7 8

8 8 6

22

Algorithmus kann mit dem falschen Resultat terminieren, wennˆhdie Distanz zutnicht unterschätzt.

obwohl die Heuristik ansonsten vernünftig aussieht (sie ist z.B.

monoton)

Was, wenn h ˆ nicht unterschätzt

f(u) =ˆ d_s[u]+ˆh(u) (ˆh=δ²_x+δ_y²)

s

16 9 4 1 0t

17 10 5 2 1

20 13 8 5 4

25 18 13 10 9 32 25 20 17 16

0 18 1 26

1 14 1 26

1 14

2 12

2 10

2 22

3 13

3 8 4 14

4 6 3 20

5 14 5 22

6 22

6 10 5 14

6 10

7 8

8 8 6

22

Algorithmus kann mit dem falschen Resultat terminieren, wennˆhdie Distanz zutnicht unterschätzt.

obwohl die Heuristik ansonsten vernünftig aussieht (sie ist z.B.

monoton)

und sie später wieder einfügen.

Das kann zu suboptimalem Verhalten im Sinne der Laufzeit des Algorithmus führen.

Wenn^bhzusätzlich zur Zulässigkeit (h(v)^b ≤h(v)für allev ∈V) auch noch monoton ist, d.h. wenn für alle(u, u⁰)∈E:

bh(u⁰)≤^bh(u) +c(u⁰, u)

dann ist der A* Algorithmus äquivalent zum Dijkstra-Algorithmus mit Kantengewichten˜c(u, v) =c(u, v) +^bh(u)−^bh(v)und kein Knoten wird aus Rentnommen und wieder eingefügt.

Ein verrücktes h ˆ

f(u) =ˆ d_s[u]+ˆh(u)

s

t

8 7 6 5 4

7 0 0 0 3

6 5 1 0 2

5 0 0 0 1

4 0 2 1 0

0 0 1 8

1 1 1 8

1 6

2 8

2 2

2 2 3 8

3 3

3 3

4 4 4

4

5 5 5 10

6 8 6

10 2 8

6 10

2 2

3 3 3 8

4 8

4 6 4 6 4 6

5 6

6 6

Algorithmus terminert mit dem korrekten Resultat, auch wenn die Abstandsheuristik nicht monoton ist

Dann kann es kann vorkommen, dass Knoten mehrfach ausR entnommen und wieder eingefügt werden.

Ein verrücktes h ˆ

f(u) =ˆ d_s[u]+ˆh(u)

s

t

8 7 6 5 4

7 0 0 0 3

6 5 1 0 2

5 0 0 0 1

4 0 2 1 0

0

1 1

1 6

2 2

2 3 3

3 3

4 4 4

4

5 5 5 10

6 8 6

10 2 8

6 10

2 2

3 3 3 8

4 8

4 6 4 6 4 6

5 6

6 6

Algorithmus terminert mit dem korrekten Resultat, auch wenn die Abstandsheuristik nicht monoton ist

Dann kann es kann vorkommen, dass Knoten mehrfach ausR entnommen und wieder eingefügt werden.

Ein verrücktes h ˆ

f(u) =ˆ d_s[u]+ˆh(u)

s

t

8 7 6 5 4

7 0 0 0 3

6 5 1 0 2

5 0 0 0 1

4 0 2 1 0

0 0

1 8

1 1 1 8

1 6

2 8

2 2

2 2 3 8

3 3

3 3

4 4 4

4

5 5 5 10

6 8 6

10 2 8

6 10

2 2

3 3 3 8

4 8

4 6 4 6 4 6

5 6

6 6

Algorithmus terminert mit dem korrekten Resultat, auch wenn die Abstandsheuristik nicht monoton ist

Dann kann es kann vorkommen, dass Knoten mehrfach ausR entnommen und wieder eingefügt werden.

Ein verrücktes h ˆ

f(u) =ˆ d_s[u]+ˆh(u)

s

t

8 7 6 5 4

7 0 0 0 3

6 5 1 0 2

5 0 0 0 1

4 0 2 1 0

0 0 1 8

1 1 1 8

1 6

2 2

2 3 3

3 3

4 4 4

4

5 5 5 10

6 8 6

10 2 8

6 10

2 2

3 3 3 8

4 8

4 6 4 6 4 6

5 6

6 6

Algorithmus terminert mit dem korrekten Resultat, auch wenn die Abstandsheuristik nicht monoton ist

Dann kann es kann vorkommen, dass Knoten mehrfach ausR entnommen und wieder eingefügt werden.

Ein verrücktes h ˆ

f(u) =ˆ d_s[u]+ˆh(u)

s

t

8 7 6 5 4

7 0 0 0 3

6 5 1 0 2

5 0 0 0 1

4 0 2 1 0

0 0 1 8

1 1 1 8

1 6

2 8

2 2

2 2

3 8

3 3

3 3

4 4 4

4

5 5 5 10

6 8 6

10 2 8

6 10

2 2

3 3 3 8

4 8

4 6 4 6 4 6

5 6

6 6

Algorithmus terminert mit dem korrekten Resultat, auch wenn die Abstandsheuristik nicht monoton ist

Dann kann es kann vorkommen, dass Knoten mehrfach ausR entnommen und wieder eingefügt werden.

Ein verrücktes h ˆ

f(u) =ˆ d_s[u]+ˆh(u)

s

t

8 7 6 5 4

7 0 0 0 3

6 5 1 0 2

5 0 0 0 1

4 0 2 1 0

0 0 1 8

1 1 1 8

1 6

2 8

2 2

2 2 3 8

3 3

3 3

4 4

5 5 5

6 8 6

10 6 10

2 3 3 3 4 8

4 6 4 6 4 6

5 6

6 6

Algorithmus terminert mit dem korrekten Resultat, auch wenn die Abstandsheuristik nicht monoton ist

Dann kann es kann vorkommen, dass Knoten mehrfach ausR entnommen und wieder eingefügt werden.

Ein verrücktes h ˆ

f(u) =ˆ d_s[u]+ˆh(u)

s

t

8 7 6 5 4

7 0 0 0 3

6 5 1 0 2

5 0 0 0 1

4 0 2 1 0

0 0 1 8

1 1 1 8

1 6

2 8

2 2

2 2 3 8

3 3

3 3

4 4 4

4

5 5 5 10

6 8 6

10 2 8

6 10

2 2

3 3 3 8

4 8

4 6 4 6 4 6

5 6

6 6

Algorithmus terminert mit dem korrekten Resultat, auch wenn die Abstandsheuristik nicht monoton ist

Dann kann es kann vorkommen, dass Knoten mehrfach ausR entnommen und wieder eingefügt werden.

Ein verrücktes h ˆ

f(u) =ˆ d_s[u]+ˆh(u)

s

t

8 7 6 5 4

7 0 0 0 3

6 5 1 0 2

5 0 0 0 1

4 0 2 1 0

0 0 1 8

1 1 1 8

1 6

2 8

2 2

2 2 3 8

3 3

3 3

4 4 4

4

5 5 5 10

6 8 6

10 6 10

2 3 3 3 4 8

4 6 4 6 4 6

5 6

6 6

Algorithmus terminert mit dem korrekten Resultat, auch wenn die Abstandsheuristik nicht monoton ist

Dann kann es kann vorkommen, dass Knoten mehrfach ausR entnommen und wieder eingefügt werden.

Ein verrücktes h ˆ

f(u) =ˆ d_s[u]+ˆh(u)

s

t

8 7 6 5 4

7 0 0 0 3

6 5 1 0 2

5 0 0 0 1

4 0 2 1 0

0 0 1 8

1 1 1 8

1 6

2 8

2 2

2 2 3 8

3 3

3 3

4 4 4

4

5 5 5 10

6 8 6

10

2 8

6 10

2 2

3 3 3 8

4 8

4 6 4 6 4 6

5 6

6 6

Algorithmus terminert mit dem korrekten Resultat, auch wenn die Abstandsheuristik nicht monoton ist

Dann kann es kann vorkommen, dass Knoten mehrfach ausR entnommen und wieder eingefügt werden.

Ein verrücktes h ˆ

f(u) =ˆ d_s[u]+ˆh(u)

s

t

8 7 6 5 4

7 0 0 0 3

6 5 1 0 2

5 0 0 0 1

4 0 2 1 0

0 0 1 8

1 1 1 8

1 6

2 8

2 2

2 2 3 8

3 3

3 3

4 4 4

4

5 5 5 10

6 8 6

10 2 8

6 10

2 2

3

4 444 5 6

Algorithmus terminert mit dem korrekten Resultat, auch wenn die Abstandsheuristik nicht monoton ist

Dann kann es kann vorkommen, dass Knoten mehrfach ausR entnommen und wieder eingefügt werden.

Ein verrücktes h ˆ

f(u) =ˆ d_s[u]+ˆh(u)

s

t

8 7 6 5 4

7 0 0 0 3

6 5 1 0 2

5 0 0 0 1

4 0 2 1 0

0 0 1 8

1 1 1 8

1 6

2 8

2 2

2 2 3 8

3 3

3 3

4 4 4

4

5 5 5 10

6 8 6

10 2 8

6 10

2 2

3 3 3 8

4 8

4 6 4 6 4 6

5 6

6 6

Algorithmus terminert mit dem korrekten Resultat, auch wenn die Abstandsheuristik nicht monoton ist

Dann kann es kann vorkommen, dass Knoten mehrfach ausR entnommen und wieder eingefügt werden.

Ein verrücktes h ˆ

f(u) =ˆ d_s[u]+ˆh(u)

s

t

8 7 6 5 4

7 0 0 0 3

6 5 1 0 2

5 0 0 0 1

4 0 2 1 0

0 0 1 8

1 1 1 8

1 6

2 8

2 2

2 2 3 8

3 3

3 3

4 4 4

4

5 5 5 10

6 8 6

10 2 8

6 10

2 2

3 3 3 8

4 8

4 6

Algorithmus terminert mit dem korrekten Resultat, auch wenn die Abstandsheuristik nicht monoton ist

Dann kann es kann vorkommen, dass Knoten mehrfach ausR entnommen und wieder eingefügt werden.