Algoritmo di Prim

In questo tutorial imparerai come funziona l'algoritmo di Prim. Inoltre, troverai esempi funzionanti dell'algoritmo di Prim in C, C ++, Java e Python.

L'algoritmo di Prim è un algoritmo di spanning tree minimo che prende un grafico come input e trova il sottoinsieme dei bordi di quel grafico che

formano un albero che include ogni vertice
ha la somma minima dei pesi tra tutti gli alberi che possono essere formati dal grafico

Come funziona l'algoritmo di Prim

Rientra in una classe di algoritmi chiamati algoritmi greedy che trovano l'ottimo locale nella speranza di trovare un ottimo globale.

Partiamo da un vertice e continuiamo ad aggiungere bordi con il peso più basso fino a raggiungere il nostro obiettivo.

I passaggi per implementare l'algoritmo di Prim sono i seguenti:

Inizializza lo spanning tree minimo con un vertice scelto a caso.
Trova tutti i bordi che collegano l'albero a nuovi vertici, trova il minimo e aggiungilo all'albero
Continua a ripetere il passaggio 2 fino a ottenere uno spanning tree minimo

Esempio di algoritmo di Prim

Inizia con un grafico ponderato

Scegli un vertice

Scegli il bordo più corto da questo vertice e aggiungilo

Scegli il vertice più vicino non ancora nella soluzione

Scegli il bordo più vicino non ancora nella soluzione, se ci sono più scelte, scegline una a caso

Ripeti finché non avere uno spanning tree

Pseudocodice dell'algoritmo di Prim

Lo pseudocodice per l'algoritmo di prim mostra come creiamo due insiemi di vertici U e VU. U contiene l'elenco dei vertici che sono stati visitati e VU l'elenco dei vertici che non sono stati visitati. Uno per uno, spostiamo i vertici dall'insieme VU all'insieme U collegando il bordo di minor peso.

 T = ∅; U = ( 1 ); while (U ≠ V) let (u, v) be the lowest cost edge such that u ∈ U and v ∈ V - U; T = T ∪ ((u, v)) U = U ∪ (v)

Esempi di Python, Java e C / C ++

Sebbene venga utilizzata la rappresentazione in matrice di adiacenza dei grafici, questo algoritmo può anche essere implementato utilizzando Adjacency List per migliorarne l'efficienza.

Python Java C C ++

 # Prim's Algorithm in Python INF = 9999999 # number of vertices in graph V = 5 # create a 2d array of size 5x5 # for adjacency matrix to represent graph G = ((0, 9, 75, 0, 0), (9, 0, 95, 19, 42), (75, 95, 0, 51, 66), (0, 19, 51, 0, 31), (0, 42, 66, 31, 0)) # create a array to track selected vertex # selected will become true otherwise false selected = (0, 0, 0, 0, 0) # set number of edge to 0 no_edge = 0 # the number of egde in minimum spanning tree will be # always less than(V - 1), where V is number of vertices in # graph # choose 0th vertex and make it true selected(0) = True # print for edge and weight print("Edge : Weight") while (no_edge  G(i)(j): minimum = G(i)(j) x = i y = j print(str(x) + "-" + str(y) + ":" + str(G(x)(y))) selected(y) = True no_edge += 1

 // Prim's Algorithm in Java import java.util.Arrays; class PGraph ( public void Prim(int G()(), int V) ( int INF = 9999999; int no_edge; // number of edge // create a array to track selected vertex // selected will become true otherwise false boolean() selected = new boolean(V); // set selected false initially Arrays.fill(selected, false); // set number of edge to 0 no_edge = 0; // the number of egde in minimum spanning tree will be // always less than (V -1), where V is number of vertices in // graph // choose 0th vertex and make it true selected(0) = true; // print for edge and weight System.out.println("Edge : Weight"); while (no_edge < V - 1) ( // For every vertex in the set S, find the all adjacent vertices // , calculate the distance from the vertex selected at step 1. // if the vertex is already in the set S, discard it otherwise // choose another vertex nearest to selected vertex at step 1. int min = INF; int x = 0; // row number int y = 0; // col number for (int i = 0; i < V; i++) ( if (selected(i) == true) ( for (int j = 0; j G(i)(j)) ( min = G(i)(j); x = i; y = j; ) ) ) ) ) System.out.println(x + " - " + y + " : " + G(x)(y)); selected(y) = true; no_edge++; ) ) public static void main(String() args) ( PGraph g = new PGraph(); // number of vertices in grapj int V = 5; // create a 2d array of size 5x5 // for adjacency matrix to represent graph int()() G = ( ( 0, 9, 75, 0, 0 ), ( 9, 0, 95, 19, 42 ), ( 75, 95, 0, 51, 66 ), ( 0, 19, 51, 0, 31 ), ( 0, 42, 66, 31, 0 ) ); g.Prim(G, V); ) )

 // Prim's Algorithm in C #include #include #define INF 9999999 // number of vertices in graph #define V 5 // create a 2d array of size 5x5 //for adjacency matrix to represent graph int G(V)(V) = ( (0, 9, 75, 0, 0), (9, 0, 95, 19, 42), (75, 95, 0, 51, 66), (0, 19, 51, 0, 31), (0, 42, 66, 31, 0)); int main() ( int no_edge; // number of edge // create a array to track selected vertex // selected will become true otherwise false int selected(V); // set selected false initially memset(selected, false, sizeof(selected)); // set number of edge to 0 no_edge = 0; // the number of egde in minimum spanning tree will be // always less than (V -1), where V is number of vertices in //graph // choose 0th vertex and make it true selected(0) = true; int x; // row number int y; // col number // print for edge and weight printf("Edge : Weight"); while (no_edge < V - 1) ( //For every vertex in the set S, find the all adjacent vertices // , calculate the distance from the vertex selected at step 1. // if the vertex is already in the set S, discard it otherwise //choose another vertex nearest to selected vertex at step 1. int min = INF; x = 0; y = 0; for (int i = 0; i < V; i++) ( if (selected(i)) ( for (int j = 0; j G(i)(j)) ( min = G(i)(j); x = i; y = j; ) ) ) ) ) printf("%d - %d : %d", x, y, G(x)(y)); selected(y) = true; no_edge++; ) return 0; )

 // Prim's Algorithm in C++ #include #include using namespace std; #define INF 9999999 // number of vertices in grapj #define V 5 // create a 2d array of size 5x5 //for adjacency matrix to represent graph int G(V)(V) = ( (0, 9, 75, 0, 0), (9, 0, 95, 19, 42), (75, 95, 0, 51, 66), (0, 19, 51, 0, 31), (0, 42, 66, 31, 0)); int main() ( int no_edge; // number of edge // create a array to track selected vertex // selected will become true otherwise false int selected(V); // set selected false initially memset(selected, false, sizeof(selected)); // set number of edge to 0 no_edge = 0; // the number of egde in minimum spanning tree will be // always less than (V -1), where V is number of vertices in //graph // choose 0th vertex and make it true selected(0) = true; int x; // row number int y; // col number // print for edge and weight cout << "Edge" << " : " << "Weight"; cout << endl; while (no_edge < V - 1) ( //For every vertex in the set S, find the all adjacent vertices // , calculate the distance from the vertex selected at step 1. // if the vertex is already in the set S, discard it otherwise //choose another vertex nearest to selected vertex at step 1. int min = INF; x = 0; y = 0; for (int i = 0; i < V; i++) ( if (selected(i)) ( for (int j = 0; j G(i)(j)) ( min = G(i)(j); x = i; y = j; ) ) ) ) ) cout << x << " - " << y << " : " << G(x)(y); cout << endl; selected(y) = true; no_edge++; ) return 0; )

Algoritmo di Prim vs Kruskal

L'algoritmo di Kruskal è un altro popolare algoritmo di albero di copertura minimo che utilizza una logica diversa per trovare l'MST di un grafico. Invece di partire da un vertice, l'algoritmo di Kruskal ordina tutti gli spigoli da basso ad alto e continua ad aggiungere gli spigoli più bassi, ignorando quegli spigoli che creano un ciclo.