ALBERO RICOPRENTE

DI COSTO MINIMO

Ricerca Operativa

1 / 12
Introduzione
• 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.
2 / 12
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 .

3 / 12
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?

4 / 12
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.
5 / 12
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.

6 / 12
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).

7 / 12
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
8 / 12
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

9 / 12
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 .

10 / 12
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 11 / 12
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

12 / 12