GRAFI: Ricerca di cammini e alberi di minimo costo

1 / 50
Ricerca di un cammino su grafo

Ricerca di un cammino

Come individuare un cammino

tra una coppia di
nodi in un grafo orientato ?

2 / 50
Ricerca di un cammino su grafo

Procedura ad "ALBERO"
ovvero
determinaz. di un cammino tra due nodi
Es :

2 5 8

1 3 6 9

4 7 10

Esiste un cammino tra 1 e 10 ???

3 / 50
Ricerca di un cammino su grafo

Algoritmo (ricerca cammino tra 1 e m)

Passo 1: Etichettare il nodo 1 con un segno qualsiasi (ad

esempio x). Tutti gli altri nodi non sono etichettati.

Passo 2: Per ogni nodo etichettato ma non esaminato, esa-

minare il nodo i individuando tutti i nodi non
etichettati raggiungibili da i con un solo arco.
Etichettare questi nodi con i.

Passo 3 : Se il nodo m è etichettato, STOP : esiste un cammi-

no.
Se nessuno dei nodi non ancora etichettati può esse-
re etichettato, STOP, non esiste un cammino.
Altrimenti, andare al passo 2

4 / 50
Ricerca di un cammino su grafo

1 2 5
2 5 8

1 3
x 1 3 6 9 8

4 7 10
6 6 7
Ordine di etichettatura ed esame:
1 , 2 , 3 , 5 , 6 , 8 , 4 , 7 , 9 , 10
Individuazione cammino da 1 a 10 (a ritroso, memorizzando le
etichette) :
10 - 7 - 6 - 3 - 1

Osservazione : i nodi e gli archi individuati dall'algoritmo

formano un albero (grafo connesso senza cicli), da qui il nome
della procedura.

5 / 50
Albero ricoprente di costo minimo
• Un famoso problema della teoria dei grafi è il problema dell’albero
ricoprente (spanning tree in inglese) di costo minimo.

• Riguarda l’individuazione di un albero che connetta tutti i vertici di

un grafo non orientato, connesso e pesato, in modo che sia
minimizzata la somma dei costi dei corrispondenti spigoli.

• Questo problema ha numerose applicazioni pratiche come, ad

esempio, la costruzione di reti stradali, elettriche e di
telecomunicazione.

• Il problema appare anche come sottoproblema da risolvere durante

l’esecuzione di algoritmi per altri problemi.

• Analizzeremo due algoritmi per risolvere il problema dell’albero

ricoprente di costo minimo:
l’algoritmo di Kruskal e l’algoritmo di Prim.
6 / 50
Albero ricoprente di costo minimo

Problema: Copertura delle rete via cavo

Sede centrale

7 / 50
Albero ricoprente di costo minimo

Un approccio un po naif

Sede centrale

Molto costoso!

8 / 50
Albero ricoprente di costo minimo

Un approccio migliore

Sede centrale

Minimizzare la quantità totale di cavi utilizzata

9 / 50
Albero ricoprente di costo minimo

• Si consideri un grafo non orientato, connesso e pesato G = (V , E )

con un insieme di vertici V e un insieme di spigoli E
(il numero di vertici è quindi |V | e il numero di spigoli è |E |).
• Un albero ricoprente di costo minimo è un sottografo di G con le
seguenti caratteristiche:
• É un albero che copre tutti i vertici di G ⇒ contiene |V | − 1 spigoli;
• Il suo costo totale, dato dalla somma dei costi dei suoi spigoli, è il
minimo costo tra quelli di tutti i possibili alberi ricoprenti di G .

10 / 50
Albero ricoprente di costo minimo: Esempio

• Nell’esempio in figura, si evidenzia in rosso un albero ricoprente di

costo minimo con spigoli (a, d), (b, e), (c, d), (d, e) e costo 15.

a 9 a 9
b b
2 6 2 6
d d
5 5 5 5
4 4
4 4
c e c e
5 5
• Come ottenere in generale un albero ricoprente di costo minimo?
• Modello di programmazione lineare del problema?

11 / 50
Albero ricoprente di costo minimo
- Un modello di programmazione lineare per il problema (cij rappresenta il
costo dello spigolo (i, j)):
xij ∈ {0, 1}
= 1 se lo spigolo (i, j) ∈ E è scelto nell’albero ricoprente; = 0 altrimenti.
X
min cij xij (minimizzazione della somma dei costi)
(i,j)∈E
X
xij = |V | − 1 (selezione di |V | − 1 spigoli)
(i,j)∈E
X
xij ≤ |S| − 1 ∀S ⊆ V
(i,j)∈E :i∈S,j∈S

(vincoli per l’eliminazione di cicli (subtour elimination constraints))

- Questo modello contiene un numero di vincoli che aumenta
esponenzialmente con l’aumentare del numero dei vertici del grafo
non applicabile in pratica.
12 / 50
Algoritmo di Kruskal

• L’algoritmo di Kruskal è un algoritmo costruttivo che permette di

trovare un albero ricoprente di costo minimo.

• Dato un grafo G = (V , E ) non orientato, connesso e pesato, i passi

dell’algoritmo sono i seguenti:
1 Selezionare uno spigolo di costo minimo;

2 Finché non sono stati individuati |V | − 1 spigoli per la soluzione,

selezionare iterativamente uno spigolo di costo minimo in modo da
evitare la formazione di cicli con gli spigoli selezionati in precedenza.

13 / 50
Algoritmo di Kruskal

• L’algoritmo si basa sull’ordinamento degli spigoli per costi non

decrescenti e sulla verifica dell’assenza di cicli ad ogni iterazione.

• Come l’algoritmo di Prim discusso in seguito, l’algoritmo di Kruskal

permette di ottenere una soluzione ottima poiché il problema soddisfa
la cosiddetta Greedy Choice Property (scelte “localmente” ottime
permettono di ottenere una soluzione “globalmente” ottima).

14 / 50
Algoritmo di Kruskal: Esempio
Iterazione 1: spigolo (a, d) X Iterazione 2: spigolo (d, e) X
a 9 a 9
b b
2 6 2 6
d d
5 5 5 5
4 4
4 4
c e c e
5 5

Iterazione 3: spigolo (c, d) X Iterazione 4: spigolo (a, c) NO

a 9
b (ciclo a − c − d − a)
2 6 a 9
b
d 2 6
5 5
d
4 5 5
4
4
c e 4
5
c e
5
15 / 50
Algoritmo di Kruskal: Esempio

Iterazione 5: spigolo (c, e) NO Iterazione 6: spigolo (b, e) X

(ciclo c − d − e − c) STOP
9 a 9
a b b
2 6 2 6

d d
5 5 5 5
4 4
4 4

c e c e
5 5

16 / 50
Algoritmo di Prim

• L’algoritmo di Prim è un algoritmo costruttivo che permette di

ottenere un albero ricoprente di costo minimo senza dover verificare
l’assenza di cicli durante le iterazioni.
• Dato un grafo G = (V , E ) non orientato, connesso e pesato,
l’algoritmo di Prim determina un albero T attraverso i seguenti passi:
1 Inserire un vertice arbitrario in T ;

2 Finché T non contiene tutti i vertici di G , inserire iterativamente in T

gli spigoli di costo minimo (ed i relativi vertici) che collegano un vertice
in T con un vertice non in T .

17 / 50
Algoritmo di Prim: Esempio (partendo dal vertice e)
Iterazione 1: {e} ∈ T Iterazione 2: {d, e} ∈ T
→ (e, d) X → (a, d) X
a 9 a 9
b b
2 6 2 6
d d
5 5 5 5
4 4
4 4
c e c e
5 5
Iterazione 3: {a, d, e} ∈ T Iterazione 4: {a, c, d, e} ∈ T
→ (c, d) X → (b, e) X
a 9 a 9
b b
2 6 2 6
d d
5 5 5 5
4 4
4 4
c e c e
5 5 18 / 50
Algoritmo di Prim: Esempio (partendo dal vertice e)

Iterazione 5: {a, b, c, d, e} ∈ T , STOP

a 9
b
2 6
d
5 5
4
4
c e
5

19 / 50
Problema del cammino minimo

• Il problema del cammino minimo è un problema classico della teoria

dei grafi.

• Consiste nel trovare, in un grafo orientato e pesato, un percorso tra

un nodo di origine (o sorgente) e un nodo di destinazione in modo
che la somma dei costi degli archi attraversati nel grafo sia minima.

• Il problema ha numerose applicazioni come, ad esempio, nelle reti

stradali e nelle reti di telecomunicazioni.

• Esistono diversi algoritmi per risolvere il problema del cammino

minimo. In particolare analizzeremo due algoritmi:
l’algoritmo di Dijkstra e l’algoritmo di Bellman-Ford.

20 / 50
Problema del cammino minimo
• Si consideri un grafo G = (V , A) orientato e pesato, con l’insieme dei
nodi (o vertici) V e l’insieme degli archi A. Si indichi con n = |V | il
numero di nodi nel grafo, con m = |A| il numero di archi e con lij il
costo di ciascun arco (i, j) ∈ A.
• Nel problema del cammino minimo, si vuole determinare il cammino
tra un nodo di origine e un nodo di destinazione del grafo G tale che
la somma dei costi dei suoi archi sia minima.
• Considereremo il seguente grafo come esempio:
4
4 5

2 5
2
7

1 5 3
2 1
1

3 6
7 21 / 50
Problema del cammino minimo

• Se non ci sono nel grafo circuiti di costo negativo (situazione possibile

se sono presenti archi con costi negativi), il problema del cammino
minimo tra due nodi s e t può essere formulato con il seguente
modello di programmazione lineare.

• Per ogni arco (i, j) ∈ A, si considera una variabile binaria xij uguale a
1 se l’arco è percorso nel cammino minimo da s a t.

• La funzione obiettivo, da minimizzare, è quindi

X
lij xij .
(i,j)∈A

22 / 50
Problema del cammino minimo

• Per il nodo s, si impone che deve essere selezionato un arco uscente:

X
xsj = 1.
j:(s,j)∈A

• Per il nodo t, si impone che deve essere selezionato un arco entrante:

X
xit = 1.
i:(i,t)∈A

• Per ogni altro nodo k, si impone che, se viene selezionato un arco

entrante, deve essere selezionato anche un arco uscente:
X X
xik = xkj (k 6= s, t).
i:(i,k)∈A j:(k,j)∈A

23 / 50
Problema del cammino minimo
Come esempio, si riporta il modello di programmazione lineare per trovare
un cammino minimo dal nodo 1 al nodo 4 nel grafo nella slide 3:

xij ∈ {0, 1} = 1 se l’arco (i, j) ∈ A è scelto nel

cammino minimo da 1 a 4; = 0
altrimenti.
x12 + x13 = 1 Vincolo nodo 1.
x24 + x54 = 1 Vincolo nodo 4.
x12 + x32 + x52 = x24 + x26 Vincolo nodo 2.
x13 = x32 + x35 + x36 Vincolo nodo 3.
x35 + x65 = x52 + x54 Vincolo nodo 5.
x26 + x36 = x65 Vincolo nodo 6.
min 7x12 + x13 + 5x32 + 4x24 + x26 +
+2x35 + 7x36 + 2x52 + 5x54 + 3x65 Funzione obiettivo.

24 / 50
Algoritmo di Dijkstra

• Per la discussione degli algoritmi, verranno considerati i seguenti

insiemi per un grafo orientato e pesato G (V , A):
• Γi : insieme dei successori del nodo i, ovvero dei nodi che ricevono un
arco proveniente dal nodo i.

• Γ−1
i : insieme dei predecessori del nodo i, ovvero dei nodi che hanno un
arco verso il nodo i.

• Un algoritmo per la ricerca dei cammini minimi da un nodo di origine

verso gli altri nodi del grafo è stato proposto da Edsger Dijkstra nel
1956.

• L’algoritmo di Dijkstra può essere applicato a grafi con costi degli

archi non negativi (lij ≥ 0 ∀(i, j) ∈ A).

25 / 50
Algoritmo di Dijkstra

• L’algoritmo di Dijkstra si basa su un processo iterativo di

etichettatura degli n nodi del grafo a partire da un certo nodo di
origine, che assumeremo essere il nodo 1 in questa trattazione.

• Nella descrizione dell’algoritmo, considereremo le seguenti definizioni:

• Π(i): costo del cammino minimo dal nodo di origine al nodo i.

• P(i): predecessore del nodo i nel cammino minimo dal nodo di origine
al vertice i ((P(i), i) ∈ A).

• S: insieme dei nodi etichettati dall’algoritmo.

• S: insieme dei nodi non etichettati dall’algoritmo.

26 / 50
Algoritmo di Dijkstra
• I passi dell’algoritmo di Dijkstra sono i seguenti:

1) S = {2, .., n}
Π(1) = 
0
l1i se i ∈ Γ1
Π(i) =
∞ altrimenti
P(i) = 1, ∀i ∈ Γ1 .

2) Trovare j ∈ S tale che Π(j) = min Π(i)

i∈S

 S = S − {j}
Porre
Se S  = 0, STOP; altrimenti andare al passo 3).

3) ∀ i ∈ Γj ∩ S porre
Π(i) = min(Π(i), Π(j) + lji )
P(i) = j se Π(i) = Π(j) + lji .
Andare al passo 2).
27 / 50
Algoritmo di Dijkstra
• Primo passo dell’algoritmo (inizializzazione):
1) S = {2, .., n}
Π(1) = 
0
l1i se i ∈ Γ1
Π(i) =
∞ altrimenti
P(i) = 1, ∀i ∈ Γ1 .

• Nel passo 1):

• Si etichetta il nodo di origine 1 (S = {2, .., n}) e si pone a zero il costo
del cammino minimo da 1 a 1 (Π(1) = 0).

• Per ciascun nodo i ∈ Γ1 successore del nodo 1, il costo del cammino

minimo da 1 a i è posto uguale al costo dell’arco che li collega
(Π(i) = l1i ). Quindi, inizialmente, si considera il nodo 1 come
predecessore di i nel cammino minimo da 1 a i (P(i) = 1).

• Per gli altri nodi del grafo, il costo del relativo cammino minimo dal
nodo 1 si pone pari ad infinito (Π(i) = ∞).
28 / 50
Algoritmo di Dijkstra

• Secondo passo dell’algoritmo:

2) Trovare j ∈ S tale che Π(j) = min Π(i)
i∈S

 S = S − {j}
Porre
Se S  = 0, STOP; altrimenti andare al passo 3).

• Nel passo 2):

• Tra i nodi non ancora etichettati, si considera il nodo j con il minimo
valore di Π (Π(j) = min Π(i)).
i∈S

• Il nodo j viene etichettato, ovvero eliminato da S (S = S − {j}).

• Se tutti i nodi sono stati etichettati (S  = 0) l’algoritmo termina,

 

altrimenti l’algoritmo va al passo 3).

29 / 50
Algoritmo di Dijkstra
• Terzo passo dell’algoritmo:
3) ∀ i ∈ Γj ∩ S porre
Π(i) = min(Π(i), Π(j) + lji )
P(i) = j se Π(i) = Π(j) + lji .
Andare al passo 2).

• Nel passo 3):

• Tra i nodi non ancora etichettati, si considera ciascun nodo i
successore del nodo j trovato nel passo precedente (i ∈ Γj ∩ S).

• Per ognuno di tali nodi, se presenti, si valuta un possibile

aggiornamento del costo del cammino minimo considerando il cammino
minimo che va da 1 a j (Π(i) = min(Π(i), Π(j) + lji )).

• Se il costo del cammino minimo Π(i) è pari a Π(j) + lji , allora il nodo j
diventa il predecessore del nodo i nel cammino minimo da 1 a i
(P(i) = j se Π(i) = Π(j) + lji ).

• L’algoritmo ritorna poi al passo 2).

30 / 50
Algoritmo di Dijkstra

• Osservando i passi 2) e 3) dell’algoritmo di Dijkstra, si nota che, una

volta che viene etichettato un nodo j, il valore di Π(j) resta invariato
nelle iterazioni successive. Tale valore costituisce proprio il costo del
cammino minimo dal nodo 1 al nodo j.

• Al termine delle iterazioni, l’algoritmo determina i valori finali di Π(i)

e P(i) (i = 2, . . . , n) per tutti i nodi del grafo.

• Considerando i valori di P(i), è possibile evidenziare i cammini minimi

nel grafo con il cosiddetto albero di supporto.

31 / 50
Algoritmo di Dijkstra: Esempio

Si riportano di seguito le iterazioni dell’algoritmo di Dijkstra per il grafo

nella slide 3:
Iterazione 1
1) S = {2, ..., 6}, Π(1) = 0, 4
4 5
Π(2) = 7, Π(3) = 1,
2 5
Π(4) = Π(5) = Π(6) = ∞, 2
7
P(2) = 1, P(3) = 1
2) j = 3, S = {2, 4, 5, 6} 1 5 3
2 1
3) Γ3 ∩ S = {2, 5, 6} 1

Π(2) = min(7, 1 + 5) = 6 3
7
6

Π(5) = min(∞, 1 + 2) = 3
Π(6) = min(∞, 1 + 7) = 8
P(2) = P(5) = P(6) = 3.

32 / 50
Algoritmo di Dijkstra: Esempio

Iterazione 2
S = {2, 4, 5, 6}, Π(2) = 6, 4
4 5
Π(4) = ∞, Π(5) = 3, Π(6) = 8
2 5
2) j = 5, S = {2, 4, 6} 2
7
3) Γ5 ∩ S = {2, 4}
1 5 3
Π(2) = min(6, 3 + 2) = 5
2 1
Π(4) = min(∞, 3 + 5) = 8 1

P(2) = 5, P(4) = 5. 3
7
6

33 / 50
Algoritmo di Dijkstra: Esempio

Iterazione 3
S = {2, 4, 6}, 4
4 5
Π(2) = 5, Π(4) = 8, Π(6) = 8
2 5
2) j = 2, S = {4, 6} 2
7
3) Γ2 ∩ S = {4, 6}
1 5 3
Π(4) = min(8, 5 + 4) = 8
2 1
Π(6) = min(8, 5 + 1) = 6, 1

P(6) = 2. 3
7
6

34 / 50
Algoritmo di Dijkstra: Esempio

Iterazione 4
S = {4, 6}, Π(4) = 8, Π(6) = 6 4
4 5
2) j = 6, S = {4}
2 5
2
3) Γ6 ∩ S = {∅}. 7

1 5 3
Iterazione 5 2
1 1
S = {4}, Π(4) = 8
  3 6
7
2) j = 4, S  = 0 ⇒ STOP.

35 / 50
Algoritmo di Dijkstra: Esempio
Si riporta infine l’albero di supporto relativo ai cammini minimi trovati.
Π(2) = 5 P(2) = 5
Π(3) = 1 P(3) = 1
Π(4) = 8 P(4) = 5
Π(5) = 3 P(5) = 3
Π(6) = 6 P(6) = 2.

4
5

2 5
2

1
2 1
1

3 6

36 / 50
Algoritmo di Dijkstra: prova di correttezza

• Si vuole provare che Π(u) rappresenti effettivamente il

cammino minimo dall’origine a u.
• Si assuma per contraddizione che u sia il primo vertice
etichettato tale per cui Π(u) non sia un cammino minimo (e
quindi il cammino minimo per u passerà per qualche altro
vertice non ancora etichettato).
• Sia x il primo vertice non etichettato sul presunto
cammino minimo per u non etichettato
etichettato x
s
u

• Π(x) deve quindi essere un camm. minimo per x e Π(x)  Π(u).

• Ma l’alg. di Dijkstra’s seleziona sempre al passo 2 il vertice con il
minimo Π(i), quindi non può aver etichettato u prima di x.

37 / 50
Algoritmo di Bellman-Ford

• Supponiamo di voler cercare il cammino minimo con un numero

massimo di archi: l’algoritmo di Dijkstra non è più applicabile.

• Alternativamente, supponiamo di non avere vincoli sul numero di

archi, ma il costo degli archi può essere sia positivo che negativo:
anche in questo caso, l’algoritmo di Dijkstra non è più applicabile.

• Nel secondo caso, non è detto che esista un ottimo: se infatti è

presente un circuito di costo negativo, percorrendo un numero infinito
di volte tale circuito si potrebbe determinare una soluzione di costo
che tende a −∞.

38 / 50
Algoritmo di Bellman-Ford

• Esempio di grafo con un circuito di costo negativo (2 − 4 − 5 − 2):

4
1 1

2 5
-4
1

1 -2 1
5

3 6
4

39 / 50
Algoritmo di Bellman-Ford

• Nei casi precedenti è possibile applicare un algoritmo proposto da

Richard Bellman e Lester Ford negli anni 1956-1958.

• L’algoritmo di Bellman-Ford può essere applicato a grafi con costi

degli archi arbitrari (lij R 0 ∀(i, j) ∈ A).

• Si basa sul paradigma della programmazione dinamica, il cui principio

generale è quello di risolvere un problema di ottimizzazione attraverso
la risoluzione di una famiglia di sottoproblemi (di cui il problema
iniziale fa parte) legati tra di loro da una relazione ricorsiva.

40 / 50
Algoritmo di Bellman-Ford
• L’algoritmo di Bellman-Ford si basa sulle seguenti considerazioni:
1 In assenza di circuiti di costo negativo in un grafo con n nodi, un
cammino minimo tra una coppia di nodi contiene al più n − 1 archi.

2 Se esiste un cammino minimo tra un nodo di origine e un altro nodo i,

tale cammino deve passare attraverso uno dei nodi j ∈ Γ−1
i , ovvero uno
dei nodi predecessori di i.

• L’algoritmo calcola, per ogni nodo i, la quantità Πk (i) che

rappresenta il costo del cammino minimo dal nodo di origine al nodo i
utilizzando al più k archi.

• Considerando valori crescenti di k, l’algoritmo determina, nel caso

peggiore, tutti i cammini minimi dal nodo di origine verso gli altri
nodi del grafo attraverso il calcolo di Πn−1 (i) per ciascun nodo i.

• Nel caso in cui Πn (i) < Πn−1 (i) per almeno un nodo i, l’algoritmo
termina concludendo che esiste un circuito di costo negativo.
41 / 50
Algoritmo di Bellman-Ford

• Assumendo come nodo di origine il nodo 1, i passi dell’algoritmo sono

i seguenti:
1) Porre Π0 (1) = 0, Π0 (i) = ∞ ∀i 6= 1,
k = 1.

2) Alla generica iterazione k, calcolare per ogni nodo i

" #
k k−1 k−1


Π (i) = min Π (i); min
−1
Π (j) + lji .
j∈Γi

3) Se Πk (i) = Πk−1 (i) per ogni nodo i, STOP.

Se k ≤ n − 1, porre k = k + 1 e tornare al passo 2).
Se k = n, allora esiste un circuito di costo negativo, STOP.

42 / 50
Algoritmo di Bellman-Ford

• Nel passo 1), l’algoritmo inizializza il costo Π0 (1) a 0 e tutti gli altri
costi Π0 (i) a ∞ (i 6= 1) per rappresentare l’impossibilità di
raggiungere un nodo diverso da 1 senza utilizzare archi.

• Nel passo 2), l’algoritmo applica la relazione ricorsiva tra i problemi

" #
 
k k−1 k−1
Π (i) = min Π (i); min Π (j) + lji ,
j∈Γ−1
i

ovvero calcola, per ogni nodo i, il costo del cammino minimo dal
nodo 1 al nodo i con al più k archi sulla base di quanto ottenuto con
i cammini minimi con al più k − 1 archi per il nodo i e per i
predecessori di i.

43 / 50
Algoritmo di Bellman-Ford

• Nel passo 3), all’iterazione k l’algoritmo confronta i costi dei cammini

minimi ottenuti con al più k (≤ n) archi con quelli ottenuti
all’iterazione precedente con al più k − 1 archi.
Se Πk (i) = Πk−1 (i) ∀i, questo significa che tutti i cammini minimi
sono ottenibili utilizzando al massimo k − 1 archi. In tal caso
l’algoritmo termina, altrimenti passa all’iterazione successiva
incrementando il valore di k di un’unità.
Se l’algoritmo esegue l’iterazione con k = n e Πn (i) < Πn−1 (i) per
almeno un nodo i, allora esiste un circuito di costo negativo e
l’algoritmo termina.

• Nota: è possibile ricavare i cammini minimi al termine dell’algoritmo

tenendo traccia nel passo 2) del predecessore di ogni nodo i nel
cammino minimo da 1 a i ad ogni iterazione k. Tale aspetto non è
trattato in questa sede.

44 / 50
Algoritmo di Bellman-Ford: Esempio
Si riportano di seguito le iterazioni dell’algoritmo di Bellman-Ford per il
grafo nella slide 3:

4
4 5

2 5
2
7

1 5 3
2 1
1

3 6
7

Inizializzazione
1) Π0 (1) = 0, Π0 (2) = Π0 (3) = Π0 (4) = Π0 (5) = Π0 (6) = ∞,
k = 1.
45 / 50
Algoritmo di Bellman-Ford: Esempio
Iterazione 1
2) Π1 (1) = 0,
Π1 (2) = min[Π0 (2), min{Π0 (1) + l12 , Π0 (3) + l32 , Π0 (5) + l52 }] = 7,
Π1 (3) = min[Π0 (3), Π0 (1) + l13 ] = 1,
Π1 (4) = min[Π0 (4), min{Π0 (2) + l24 , Π0 (5) + l54 }] = ∞,
Π1 (5) = min[Π0 (5), min{Π0 (3) + l35 , Π0 (6) + l65 }] = ∞,
Π1 (6) = min[Π0 (6), min{Π0 (2) + l26 , Π0 (3) + l36 }] = ∞.
3) Π1 (i) = Π0 (i) ∀i ? no ⇒ k ≤ 5 ? sı̀ ⇒ k = 2.
4
4 5

2 5
2
7

1 5 3
2 1
1

3 6
7
46 / 50
Algoritmo di Bellman-Ford: Esempio
Iterazione 2
2) Π2 (1) = 0,
Π2 (2) = min[Π1 (2), min{Π1 (1) + l12 , Π1 (3) + l32 , Π1 (5) + l52 }] = 6,
Π2 (3) = min[Π1 (3), Π1 (1) + l13 ] = 1,
Π2 (4) = min[Π1 (4), min{Π1 (2) + l24 , Π1 (5) + l54 }] = 11,
Π2 (5) = min[Π1 (5), min{Π1 (3) + l35 , Π1 (6) + l65 }] = 3,
Π2 (6) = min[Π1 (6), min{Π1 (2) + l26 , Π1 (3) + l36 }] = 8.
3) Π2 (i) = Π1 (i) ∀i ? no ⇒ k ≤ 5 ? sı̀ ⇒ k = 3.
4
4 5

2 5
2
7

1 5 3
2 1
1

3 6
7
47 / 50
Algoritmo di Bellman-Ford: Esempio
Iterazione 3
2) Π3 (1) = 0,
Π3 (2) = min[Π2 (2), min{Π2 (1) + l12 , Π2 (3) + l32 , Π2 (5) + l52 }] = 5,
Π3 (3) = min[Π2 (3), Π2 (1) + l13 ] = 1,
Π3 (4) = min[Π2 (4), min{Π2 (2) + l24 , Π2 (5) + l54 }] = 8,
Π3 (5) = min[Π2 (5), min{Π2 (3) + l35 , Π2 (6) + l65 }] = 3,
Π3 (6) = min[Π2 (6), min{Π2 (2) + l26 , Π2 (3) + l36 }] = 7.
3) Π3 (i) = Π2 (i) ∀i ? no ⇒ k ≤ 5 ? sı̀ ⇒ k = 4.
4
4 5

2 5
2
7

1 5 3
2 1
1

3 6
7
48 / 50
Algoritmo di Bellman-Ford: Esempio
Iterazione 4
2) Π4 (1) = 0,
Π4 (2) = min[Π3 (2), min{Π3 (1) + l12 , Π3 (3) + l32 , Π3 (5) + l52 }] = 5,
Π4 (3) = min[Π3 (3), Π3 (1) + l13 ] = 1,
Π4 (4) = min[Π3 (4), min{Π3 (2) + l24 , Π3 (5) + l54 }] = 8,
Π4 (5) = min[Π3 (5), min{Π3 (3) + l35 , Π3 (6) + l65 }] = 3,
Π4 (6) = min[Π3 (6), min{Π3 (2) + l26 , Π3 (3) + l36 }] = 6.
3) Π4 (i) = Π3 (i) ∀i ? no ⇒ k ≤ 5 ? sı̀ ⇒ k = 5.
4
4 5

2 5
2
7

1 5 3
2 1
1

3 6
7
49 / 50
Algoritmo di Bellman-Ford: Esempio
Iterazione 5
2) Π5 (1) = 0,
Π5 (2) = min[Π4 (2), min{Π4 (1) + l12 , Π4 (3) + l32 , Π4 (5) + l52 }] = 5,
Π5 (3) = min[Π4 (3), Π4 (1) + l13 ] = 1,
Π5 (4) = min[Π4 (4), min{Π4 (2) + l24 , Π4 (5) + l54 }] = 8,
Π5 (5) = min[Π4 (5), min{Π4 (3) + l35 , Π4 (6) + l65 }] = 3,
Π5 (6) = min[Π4 (6), min{Π4 (2) + l26 , Π4 (3) + l36 }] = 6.
3) Π5 (i) = Π4 (i) ∀i ? sı̀, STOP.
4
4 5

2 5
2
7

1 5 3
2 1
1

3 6
7
50 / 50