Prim’s algorithm using priority_queue in STL

30 Jun, 2022
Given an undirected, connected and weighted graph, find Minimum Spanning Tree (MST) of the graph using Prim’s algorithm.
Input : Adjacency List representation
        of above graph
Output :  Edges in MST
          0 - 1
          1 - 2
          2 - 3
          3 - 4
          2 - 5
          5 - 6
          6 - 7
          2 - 8


Note:  There are two possible MSTs, the other
        MST includes edge 0-7 in place of 1-2. 
We have discussed below Prim’s MST implementations. 
Prim’s Algorithm for Adjacency Matrix Representation (In C/C++ with time complexity O(v2)
Prim’s Algorithm for Adjacency List Representation (In C with Time Complexity O(ELogV))
The second implementation is time complexity wise better, but is really complex as we have implemented our own priority queue. STL provides priority_queue, but the provided priority queue doesn’t support decrease key operation. And in Prim’s algorithm, we need a priority queue and below operations on priority queue : 
ExtractMin : from all those vertices which have not yet been included in MST, we need to get vertex with minimum key value.
DecreaseKey : After extracting vertex we need to update keys of its adjacent vertices, and if new key is smaller, then update that in data structure.
The algorithm discussed here can be modified so that decrease key is never required. The idea is, not to insert all vertices in priority queue, but only those which are not MST and have been visited through a vertex that has included in MST. We keep track of vertices included in MST in a separate boolean array inMST[].
1) Initialize keys of all vertices as infinite and 
   parent of every vertex as -1.

2) Create an empty priority_queue pq.  Every item
   of pq is a pair (weight, vertex). Weight (or 
   key) is used  as first item  of pair
   as first item is by default used to compare
   two pairs.

3) Initialize all vertices as not part of MST yet.
   We use boolean array inMST[] for this purpose.
   This array is required to make sure that an already
   considered vertex is not included in pq again. This
   is where Prim's implementation differs from Dijkstra.
   In Dijkstra's algorithm, we didn't need this array as
   distances always increase. We require this array here 
   because key value of a processed vertex may decrease
   if not checked.

4) Insert source vertex into pq and make its key as 0.

5) While either pq doesn't become empty 
    a) Extract minimum key vertex from pq. 
       Let the extracted vertex be u.

    b) Include u in MST using inMST[u] = true.

    c) Loop through all adjacent of u and do 
       following for every vertex v.

           // If weight of edge (u,v) is smaller than
           // key of v and v is not already in MST
           If inMST[v] = false && key[v] > weight(u, v)

               (i) Update key of v, i.e., do
                     key[v] = weight(u, v)
               (ii) Insert v into the pq 
               (iv) parent[v] = u
               
6) Print MST edges using parent array.
Below is C++ implementation of above idea. 
C++
// STL implementation of Prim's algorithm for MST#include<bits/stdc++.h>using namespace std;# define INF 0x3f3f3f3f // iPair ==>  Integer Pairtypedef pair<int, int> iPair; // This class represents a directed graph using// adjacency list representationclass Graph{    int V;    // No. of vertices     // In a weighted graph, we need to store vertex    // and weight pair for every edge    list< pair<int, int> > *adj; public:    Graph(int V);  // Constructor     // function to add an edge to graph    void addEdge(int u, int v, int w);     // Print MST using Prim's algorithm    void primMST();}; // Allocates memory for adjacency listGraph::Graph(int V){    this->V = V;    adj = new list<iPair> [V];} void Graph::addEdge(int u, int v, int w){    adj[u].push_back(make_pair(v, w));    adj[v].push_back(make_pair(u, w));} // Prints shortest paths from src to all other verticesvoid Graph::primMST(){    // Create a priority queue to store vertices that    // are being primMST. This is weird syntax in C++.    // Refer below link for details of this syntax    // http://geeksquiz.com/implement-min-heap-using-stl/    priority_queue< iPair, vector <iPair> , greater<iPair> > pq;     int src = 0; // Taking vertex 0 as source     // Create a vector for keys and initialize all    // keys as infinite (INF)    vector<int> key(V, INF);     // To store parent array which in turn store MST    vector<int> parent(V, -1);     // To keep track of vertices included in MST    vector<bool> inMST(V, false);     // Insert source itself in priority queue and initialize    // its key as 0.    pq.push(make_pair(0, src));    key[src] = 0;     /* Looping till priority queue becomes empty */    while (!pq.empty())    {        // The first vertex in pair is the minimum key        // vertex, extract it from priority queue.        // vertex label is stored in second of pair (it        // has to be done this way to keep the vertices        // sorted key (key must be first item        // in pair)        int u = pq.top().second;        pq.pop();                   //Different key values for same vertex may exist in the priority queue.          //The one with the least key value is always processed first.          //Therefore, ignore the rest.          if(inMST[u] == true){            continue;        }               inMST[u] = true;  // Include vertex in MST         // 'i' is used to get all adjacent vertices of a vertex        list< pair<int, int> >::iterator i;        for (i = adj[u].begin(); i != adj[u].end(); ++i)        {            // Get vertex label and weight of current adjacent            // of u.            int v = (*i).first;            int weight = (*i).second;             //  If v is not in MST and weight of (u,v) is smaller            // than current key of v            if (inMST[v] == false && key[v] > weight)            {                // Updating key of v                key[v] = weight;                pq.push(make_pair(key[v], v));                parent[v] = u;            }        }    }     // Print edges of MST using parent array    for (int i = 1; i < V; ++i)        printf("%d - %d\n", parent[i], i);} // Driver program to test methods of graph classint main(){    // create the graph given in above figure    int V = 9;    Graph g(V);     //  making above shown graph    g.addEdge(0, 1, 4);    g.addEdge(0, 7, 8);    g.addEdge(1, 2, 8);    g.addEdge(1, 7, 11);    g.addEdge(2, 3, 7);    g.addEdge(2, 8, 2);    g.addEdge(2, 5, 4);    g.addEdge(3, 4, 9);    g.addEdge(3, 5, 14);    g.addEdge(4, 5, 10);    g.addEdge(5, 6, 2);    g.addEdge(6, 7, 1);    g.addEdge(6, 8, 6);    g.addEdge(7, 8, 7);     g.primMST();     return 0;}
0 - 1
1 - 2
2 - 3
3 - 4
2 - 5
5 - 6
6 - 7
2 - 8
Time complexity : O(E Log V))
A Quicker Implementation using array of vectors representation of a weighted graph : 
C++
// STL implementation of Prim's algorithm for MST#include<bits/stdc++.h>using namespace std;# define INF 0x3f3f3f3f // iPair ==> Integer Pairtypedef pair<int, int> iPair; // To add an edgevoid addEdge(vector <pair<int, int> > adj[], int u,                                     int v, int wt){    adj[u].push_back(make_pair(v, wt));    adj[v].push_back(make_pair(u, wt));} // Prints shortest paths from src to all other verticesvoid primMST(vector<pair<int,int> > adj[], int V){    // Create a priority queue to store vertices that    // are being primMST. This is weird syntax in C++.    // Refer below link for details of this syntax    // http://geeksquiz.com/implement-min-heap-using-stl/    priority_queue< iPair, vector <iPair> , greater<iPair> > pq;     int src = 0; // Taking vertex 0 as source     // Create a vector for keys and initialize all    // keys as infinite (INF)    vector<int> key(V, INF);     // To store parent array which in turn store MST    vector<int> parent(V, -1);     // To keep track of vertices included in MST    vector<bool> inMST(V, false);     // Insert source itself in priority queue and initialize    // its key as 0.    pq.push(make_pair(0, src));    key[src] = 0;     /* Looping till priority queue becomes empty */    while (!pq.empty())    {        // The first vertex in pair is the minimum key        // vertex, extract it from priority queue.        // vertex label is stored in second of pair (it        // has to be done this way to keep the vertices        // sorted key (key must be first item        // in pair)        int u = pq.top().second;        pq.pop();           //Different key values for same vertex may exist in the priority queue.          //The one with the least key value is always processed first.          //Therefore, ignore the rest.          if(inMST[u] == true){            continue;        }               inMST[u] = true; // Include vertex in MST         // Traverse all adjacent of u        for (auto x : adj[u])        {            // Get vertex label and weight of current adjacent            // of u.            int v = x.first;            int weight = x.second;             // If v is not in MST and weight of (u,v) is smaller            // than current key of v            if (inMST[v] == false && key[v] > weight)            {                // Updating key of v                key[v] = weight;                pq.push(make_pair(key[v], v));                parent[v] = u;            }        }    }     // Print edges of MST using parent array    for (int i = 1; i < V; ++i)        printf("%d - %d\n", parent[i], i);} // Driver program to test methods of graph classint main(){    int V = 9;    vector<iPair > adj[V];     // making above shown graph    addEdge(adj, 0, 1, 4);    addEdge(adj, 0, 7, 8);    addEdge(adj, 1, 2, 8);    addEdge(adj, 1, 7, 11);    addEdge(adj, 2, 3, 7);    addEdge(adj, 2, 8, 2);    addEdge(adj, 2, 5, 4);    addEdge(adj, 3, 4, 9);    addEdge(adj, 3, 5, 14);    addEdge(adj, 4, 5, 10);    addEdge(adj, 5, 6, 2);    addEdge(adj, 6, 7, 1);    addEdge(adj, 6, 8, 6);    addEdge(adj, 7, 8, 7);     primMST(adj, V);     return 0;}
0 - 1
1 - 2
2 - 3
3 - 4
2 - 5
5 - 6
6 - 7
2 - 8
Note: Like Dijkstra’s priority_queue implementation, we may have multiple entries for same vertex as we do not (and we can not) make isMST[v] = true in if condition. 
C++
Java
Python3
C#
Javascript
// If v is not in MST and weight of (u,v) is smaller // than current key of v if (inMST[v] == false && key[v] > weight) {      // Updating key of v      key[v] = weight;      pq.push(make_pair(key[v], v));      parent[v] = u;}
// If v is not in MST and weight of (u,v) is smaller// than current key of v  if (inMST[v] == false && key[v] > weight){     // Updating key of v  key[v] = weight;  pq.add(new Pair<Integer, Integer>(key[v], v));  parent[v] = u;}  // This code is contributed by avanitrachhadiya2155
# If v is not in MST and weight of (u,v) is smaller# than current key of v if (inMST[v] == False and key[v] > weight) :   # Updating key of v  key[v] = weight  pq.append([key[v], v])  parent[v] = u     # This code is contributed by divyeshrabadiya07.
// If v is not in MST and weight of (u,v) is smaller// than current key of v if (inMST[v] == false && key[v] > weight){  // Updating key of v  key[v] = weight;  pq.Add(new Tuple<int,int>(key[v], v));  parent[v] = u;} // This code is contributed by divyesh072019.
<script> // If v is not in MST and weight of (u,v)// is smaller than current key of vif (inMST[v] == false && key[v] > weight){         // Updating key of v    key[v] = weight;    value = [key[v], v];    pq.push(value);    parent[v] = u;} // This code is contributed by suresh07 </script>
But as explained in Dijkstra’s algorithm, time complexity remains O(E Log V) as there will be at most O(E) vertices in priority queue and O(Log E) is same as O(Log V).
Unlike Dijkstra’s implementation, a boolean array inMST[] is mandatory here because the key values of newly inserted items can be less than the key values of extracted items. So we must not consider extracted items.
This article is contributed by Shubham Agrawal. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.
divyesh072019
divyeshrabadiya07
avanitrachhadiya2155
suresh07
sandravsnair
surindertarika1234
surinderdawra388
adityakumar129
sagartomar9927
hardikkoriintern
cpp-priority-queue
MST
priority-queue
STL
Graph
Graph
STL
priority-queue
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Find if there is a path between two vertices in a directed graph
Introduction to Data Structures
Find if there is a path between two vertices in an undirected graph
What is Data Structure: Types, Classifications and Applications
Top 50 Graph Coding Problems for Interviews
K Centers Problem | Set 1 (Greedy Approximate Algorithm)
Bridges in a graph
Real-time application of Data Structures
Longest Path in a Directed Acyclic Graph
Water Jug problem using BFS