cammini minimi in un grafo orientato pesato -...

Ugo de' Liguoro - Algoritmi e Seprimentazioni 03/04 Lez. 19

Cammini minimi in un grafo orientato pesato

Algoritmi di Dijkstra e Bellman-Ford per il problema del cammino minimo

da sorgente singola


Un problema di “percorso”

Dati una mappa stradale (con distanze ad es. in chilometri) ed un punto di partenza s trovare i percorsi più brevi da s a ciascuna delle altre località


Problemi di ottimizzazione

Problema: data una misura (costo o obiettivo) individuare una soluzione ammissibile la cui misura sia minima o massima

Problema: data una misura (costo o obiettivo) individuare una soluzione ammissibile la cui misura sia minima o massima

Senza offesa, questi due vorrei vederli il meno

possibile


Grafi pesati

9

ℜ→Ap :

3.5

1.51.8

2.6

2.6

− 7.1 − 2.1

5.1

6.9

4.5Anche se

non nel mio casoI pesi possono

essere anche negativi

G = (N, A, p)Funzione “peso”


Peso di un cammino e distanze

),(),(),(),,,( 1211010 kkk vvpvvpvvpvvvp −+++= LK

Il peso di un cammino è la somma dei pesi dei suoi archi:

La distanza di un vertice dall’altro è il minimo dei pesi tra tutti i cammini che congiungono il primo al secondo (se esistono):

∞=

altrimentiesistono ne se a da cammino :)(min

),(vuccp

vuδ


Cicli a somma negativa

u

b

c

d

a v3

2

1

– 7

– 1

5

15712),,,( −=+−−=dcbap

Ma quanto vale δ(u,v) ?

Perché δ(u,v) sia sempre definito assumeremo che non ci siano cicli a somma negativa.


Sottocammini di quello ottimo

c2

v1 vi vj vk

c1 c4

c3

)()()()()()()()( allora )()( se

421421431431

23

cccpcpcpcpcpcpcpcccpcpcp

=++<++=<

Se un cammino è ottimo, tali sono tutti i suoi sottocammini.


Coperture, ovvero soluzioni

Un albero T è una copertura di G se è un albero sorgente ed un sottografo di G che comprende tutti i suoi vertici.

a b

c d

G

2 5

3

1

a

bc

d

a

c

b

dT1

T2

11

32 2

5

Ci sono due coperture-soluzioni


Coperture, ovvero soluzioni

Se s è la radice di T , v in T e c il cammino da s a v allora:

d[v] = p(c) = δT(s,v) La distanza s, vin T

a b

c d

G

2 5

3

1

a

bc

d

a

c

b

dT1

T2

11

32 2

5

8][,7][,2][4][,3][,2][

222

111

======

ddbdcdddbdcd


Soluzioni ottime

T è ottimo per G da s se è una soluzione e per ogni v:

d[v] = δG(s,v) La distanza s, vin G

a b

c d

G

2 5

3

1

a

bc

d

a

c

b

dT1

T2

11

32 2

5

T1 è ottimo per G da a


Archi di una soluzione ottima

Supponiamo che T sia ottimo per G da s:

),(][][ allora ),( se vupudvdTvu +=∈

s uc

v ∈ T

u′∉ Tc′

),(][][ allora ),( se vupudvdTvu ′+′≤∉′


Il teorema di Bellman

Teorema. Se per ogni arco (u,v), d[v] ≤ d[u] + p(u, v), con = quando (u,v) ∈ T, allora T è ottimo

Teorema. Se per ogni arco (u,v), d[v] ≤ d[u] + p(u, v), con = quando (u,v) ∈ T, allora T è ottimo

Per assurdo sia ottimo T′ ma non T: allora esiste w t.c.

d′[w] < d[w]

Nel cammino che in T′ conduce a w, consideriamo il primo arco (u, v) per cui d′[u] = d[u] ma d′[v] < d[v]:

ipotesiper ][][][ ),(][ottimo è perché ),(][][

vdududvupud

Tvupudvd

≥=′+=

′+′=′


Schema di risoluzioneCamminiMinimi (G = (N, A, p), s)foreach v ∈ N do d[v] ← ∞d[s] ← 0, T ←∅, S ← s while S ≠ ∅ do

sia u ∈ S, S ← S – uforeach (u, v) ∈ A do

if d[v] > d[u] + p(u, v) then // c’è un cammino migliore da s a vd[v] ← d[u] + p(u, v) rimpiazza in T l’arco incidente in v con (u, v)S ← S ∪ u

return T

rilas

sam

ento

Se nessun arco della forma (w, v) era in T, allora “rimpiazza” =

aggiungi


Cammini minimi e BFS

Differenze

Se v è raggiungibile da più di un cammino allora sarà in S più di una volta

Somiglianze

Da un nodo consideriamo tutti i suoi adiacenti, inoltre:

1. S è la Frontiera

2. Esterni = v: d[v] = ∞

3. Interni = v: d[v] < ∞ – SNon si tiene conto

del fatto che un vertice possa essere

stato visitato


Algoritmo di Dijkstra

Supponiamo che i pesi siano positivi:• S è una coda di priorità dove

Priorità(v, S) = d[v]• Se d[v] < ∞ e v ∉ S, allora d[v] = δ (s, v):

s uc

v ∈ T

scoprire da ancora nodi dai dipendenon ),(),(:),(min),(

induttiva ipotesi ),()(][

vsAwuwupvup

uscpud

δ

δ∈=

==Qui usiamo

l’ipotesi che i pesi siano positivi


Algoritmo di Dijkstra

Dijkstra-Johnson (G = (N, A, p), s) // Pre: p ha valori positiviforeach v ∈ N do d[v] ←∞;d[s] ← 0; Q ← EmptyPriorityQueue () foreach v ∈ N do Enqueue(v, d[v], Q) // la priorità di ogni v in Q è d[v]while not IsEmptyQueue(Q) do

u ← ExtractMin(Q);foreach (u, v) ∈ A do

if d[v] > d[u] + p(u,v) thend[v] ← d[u] + p(u,v)rimpiazza in T l’arco incidente in v con (u, v)RedefinePrior(v, d[v], Q)

return T

Esssenziale se Q èuno heap: la

posizione di vcambia

Nessun reinserimento


Esecuzione dell’algoritmo di Dijkstra

∞ ∞∞

f g

b

i j

1

1 1

3

∞∞

2 ca

h

d

1

4

10

1

5

∞e 30

7

9 2

∞ ∞ ∞

Iterazione No

0



∞ ∞4

f g

b

i j

1

1 1

3

∞∞

2 ca

h

d

1

4

10

1

5

∞e 30

7

9 2

1 ∞ ∞

Iterazione No

1



∞ ∞4

f g

b

i j

1

1 1

3

∞∞

2 ca

h

d

1

4

10

1

5

6e 30

7

9 2

1 10 ∞

Iterazione No

2



∞ ∞4

f g

b

i j

1

1 1

3

∞∞

2 ca

h

d

1

4

10

1

5

5e 30

7

9 2

1 10 ∞

Iterazione No

3



∞ ∞4

f g

b

i j

1

1 1

3

8∞

2 ca

h

d

1

4

10

1

5

5e 30

7

9 2

1 10 ∞

Iterazione No

4



9 114

f g

b

i j

1

1 1

3

815

2 ca

h

d

1

4

10

1

5

5e 30

7

9 2

1 9 ∞

Iterazione No

5



9 114

f g

b

i j

1

1 1

3

815

2 ca

h

d

1

4

10

1

5

5e 30

7

9 2

1 9 11

Iterazione No

6



9 114

f g

b

i j

1

1 1

3

815

2 ca

h

d

1

4

10

1

5

5e 30

7

9 2

1 9 11

Iterazione No

7



9 114

f g

b

i j

1

1 1

3

815

2 ca

h

d

1

4

10

1

5

5e 30

7

9 2

1 9 11

Iterazione No

8



9 114

f g

b

i j

1

1 1

3

812

2 ca

h

d

1

4

10

1

5

5e 30

7

9 2

1 9 11

Iterazione No

9



9 114

f g

b

i j

1

1 1

3

812

2 ca

h

d

1

4

10

1

5

5e 30

7

9 2

1 9 11

Iterazione No

10


E se ci sono pesi negativi?

∞

a

d

2

− 3

1

b0 ∞

1 3c

Iterazione No∞

0


E se ci sono pesi negativi?2

a

d

2

− 3

1

b0 ∞

1 3c

Iterazione No1

1



a

d

2

− 3

1

b0 4

1 3c

Iterazione No1

2



a

d

2

− 3

1

b0 3

1 3c

Iterazione No1

3



a

d

2

− 3

1

b0 3

1 3c

Iterazione No1

42332),,,(),( =+−== dcabpdbδ


Un problema con pesi negativi

“Un proprietario di TIR è libero di spostare containers da una città all’altra. Un viaggio dalla città i alla città j porta un profitto di pij euro se c’è un container da trasportare, ma provoca una perdita di pij euro se il TIR viaggia scarico. Assumendo profitti pij > 0 e perdite pij < 0, il percorso più vantaggioso tra due città corrisponde ad un cammino minimo, in cui le lunghezze (i pesi) degli archi sono – pij”.

Bertossi, esempio 10.1Per aggirare l’ostacolo

proviamo a “rilassare” tutti gli archi a ripetizione


Algoritmo di Bellman-FordBF (G = (N, A, p), s)foreach v ∈ N do d[v] ← ∞d[s] ← 0, T ←∅, relax ← truewhile relax do

relax ← falseforeach (u, v) ∈ A do

if d[v] > d[u] + p(u,v) thenrelax ← trued[v] ← d[u] + p(u,v)rimpiazza in T l’arco incidente in v con (u, v)

return T

Questo algoritmo termina? Se si, entro

quante iterazioni?


Algoritmo di Bellman-Ford

Teorema. Se G non ha cicli a somma negativa ed esiste una copertura con radice in s, allora BF termina entro n – 1 iterazioni, dove n = |N|.


Sia c = v0, …, vk un cammino ottimo in G, con s = v0: per induzione su k dimostriamo che:

i. d[vi] ≥ δ(s, vi), per i = 0, …, k è un invariante di ciclo

ii. d[vk] = δ(s, vk) dopo al più k iterazioni E in un cammino ottimo ci sono ≤ n – 1

archi

Base: k = 0, allora δ(s, v0) = δ(s, s) = 0 = d[v0] per inizializzazione





Passo: k > 0 e c = v0, …, vk – 1, vk :

ind. ip. ),(][ottimo sott. ),(),(

),(),,()(),(

11

110

110

kkk

kkk

kkkk

vvpvdvvpvv

vvpvvpcpvs

−−

−−

−−

+=+=

+==δ

δ K

Per ip. ind. d[vk ] ≥ δ(s, vk), e se è > allora per rilassamentod[vk ] = d[vk – 1] + p(vk – 1,vk) = δ(s, vk) dopo la k-esima iterazione.



Bellman-Ford (G = (N, A, p), s)foreach v ∈ N do d[v] ← ∞d[s] ← 0, T ←∅

for i ← 1 to |N|– 1 do

foreach (u, v) ∈ A do

if d[v] > d[u] + p(u,v) then

d[v] ← d[u] + p(u,v)rimpiazza in T l’arco incidente in v con (u, v)

return T


Analisi della complessità

Dijkstra-Johnson: ExtractMin si esegue n = |N| volte, mentre RedefinePrior si esegue al più m = |A| volte.• Se Q è un vettore, ExtractMin è O(n), ma

RedefinePrior è O(1), dunqueO(n2 + m) = O(n2)

• Se Q è uno heap, sia ExtractMin che RedefinePrior sono O(log n) mentre l’inizializzazione è O(n), dunque, se una copertura esiste,

O(n + n log n + m log n) = O(m log n)

Lo heap conviene se m non è Ω(n2) (grafo sparso)


Analisi della complessità

Bellman-Ford: in ognuna delle n – 1 iterazioni si esplorano al più m archi:

O(nm)Poiché m è O(n2), abbiamo

O(n3).


Il corso di “Algoritmi” è finito:

non sei contento?

Sicuro se sopravvivo anche questa volta …

cammini minimi in un grafo orientato pesato -...

Documents