Prim’s Minimum Spanning Tree (MST) | Greedy Algo-5

13 Jun, 2022
We have discussed Kruskal’s algorithm for Minimum Spanning Tree. Like Kruskal’s algorithm, Prim’s algorithm is also a Greedy algorithm. It starts with an empty spanning tree. The idea is to maintain two sets of vertices. The first set contains the vertices already included in the MST, the other set contains the vertices not yet included. At every step, it considers all the edges that connect the two sets and picks the minimum weight edge from these edges. After picking the edge, it moves the other endpoint of the edge to the set containing MST. A group of edges that connects two sets of vertices in a graph is called cut in graph theory. So, at every step of Prim’s algorithm, we find a cut (of two sets, one contains the vertices already included in MST and the other contains the rest of the vertices), pick the minimum weight edge from the cut, and include this vertex to MST Set (the set that contains already included vertices).
How does Prim’s Algorithm Work? The idea behind Prim’s algorithm is simple, a spanning tree means all vertices must be connected. So the two disjoint subsets (discussed above) of vertices must be connected to make a Spanning Tree. And they must be connected with the minimum weight edge to make it a Minimum Spanning Tree.
Algorithm 1) Create a set mstSet that keeps track of vertices already included in MST. 2) Assign a key value to all vertices in the input graph. Initialize all key values as INFINITE. Assign the key value as 0 for the first vertex so that it is picked first. 3) While mstSet doesn’t include all vertices ....a) Pick a vertex u which is not there in mstSet and has a minimum key value. ....b) Include u to mstSet. ....c) Update key value of all adjacent vertices of u. To update the key values, iterate through all adjacent vertices. For every adjacent vertex v, if the weight of edge u-v is less than the previous key value of v, update the key value as the weight of u-vThe idea of using key values is to pick the minimum weight edge from cut. The key values are used only for vertices that are not yet included in MST, the key value for these vertices indicates the minimum weight edges connecting them to the set of vertices included in MST.  
Let us understand with the following example:  
The set mstSet is initially empty and keys assigned to vertices are {0, INF, INF, INF, INF, INF, INF, INF} where INF indicates infinite. Now pick the vertex with the minimum key value. The vertex 0 is picked, include it in mstSet. So mstSet becomes {0}. After including to mstSet, update key values of adjacent vertices. Adjacent vertices of 0 are 1 and 7. The key values of 1 and 7 are updated as 4 and 8. Following subgraph shows vertices and their key values, only the vertices with finite key values are shown. The vertices included in MST are shown in green color.
Chapters
descriptions off, selected
captions settings, opens captions settings dialog
captions off, selected
English
This is a modal window.
Beginning of dialog window. Escape will cancel and close the window.
End of dialog window.
Pick the vertex with minimum key value and not already included in MST (not in mstSET). The vertex 1 is picked and added to mstSet. So mstSet now becomes {0, 1}. Update the key values of adjacent vertices of 1. The key value of vertex 2 becomes 8. 
Pick the vertex with minimum key value and not already included in MST (not in mstSET). We can either pick vertex 7 or vertex 2, let vertex 7 is picked. So mstSet now becomes {0, 1, 7}. Update the key values of adjacent vertices of 7. The key value of vertex 6 and 8 becomes finite (1 and 7 respectively).  
Pick the vertex with minimum key value and not already included in MST (not in mstSET). Vertex 6 is picked. So mstSet now becomes {0, 1, 7, 6}. Update the key values of adjacent vertices of 6. The key value of vertex 5 and 8 are updated. 
We repeat the above steps until mstSet includes all vertices of given graph. Finally, we get the following graph. 
 
How to implement the above algorithm? We use a boolean array mstSet[] to represent the set of vertices included in MST. If a value mstSet[v] is true, then vertex v is included in MST, otherwise not. Array key[] is used to store key values of all vertices. Another array parent[] to store indexes of parent nodes in MST. The parent array is the output array which is used to show the constructed MST. 
C++
C
Java
Python3
C#
Javascript
// A C++ program for Prim's Minimum// Spanning Tree (MST) algorithm. The program is// for adjacency matrix representation of the graph#include <bits/stdc++.h>using namespace std; // Number of vertices in the graph#define V 5 // A utility function to find the vertex with// minimum key value, from the set of vertices// not yet included in MSTint minKey(int key[], bool mstSet[]){    // Initialize min value    int min = INT_MAX, min_index;     for (int v = 0; v < V; v++)        if (mstSet[v] == false && key[v] < min)            min = key[v], min_index = v;     return min_index;} // A utility function to print the// constructed MST stored in parent[]void printMST(int parent[], int graph[V][V]){    cout<<"Edge \tWeight\n";    for (int i = 1; i < V; i++)        cout<<parent[i]<<" - "<<i<<" \t"<<graph[i][parent[i]]<<" \n";} // Function to construct and print MST for// a graph represented using adjacency// matrix representationvoid primMST(int graph[V][V]){    // Array to store constructed MST    int parent[V];         // Key values used to pick minimum weight edge in cut    int key[V];         // To represent set of vertices included in MST    bool mstSet[V];     // Initialize all keys as INFINITE    for (int i = 0; i < V; i++)        key[i] = INT_MAX, mstSet[i] = false;     // Always include first 1st vertex in MST.    // Make key 0 so that this vertex is picked as first vertex.    key[0] = 0;    parent[0] = -1; // First node is always root of MST     // The MST will have V vertices    for (int count = 0; count < V - 1; count++)    {        // Pick the minimum key vertex from the        // set of vertices not yet included in MST        int u = minKey(key, mstSet);         // Add the picked vertex to the MST Set        mstSet[u] = true;         // Update key value and parent index of        // the adjacent vertices of the picked vertex.        // Consider only those vertices which are not        // yet included in MST        for (int v = 0; v < V; v++)             // graph[u][v] is non zero only for adjacent vertices of m            // mstSet[v] is false for vertices not yet included in MST            // Update the key only if graph[u][v] is smaller than key[v]            if (graph[u][v] && mstSet[v] == false && graph[u][v] < key[v])                parent[v] = u, key[v] = graph[u][v];    }     // print the constructed MST    printMST(parent, graph);} // Driver codeint main(){    /* Let us create the following graph        2 3    (0)--(1)--(2)    | / \ |    6| 8/ \5 |7    | / \ |    (3)-------(4)            9     */    int graph[V][V] = { { 0, 2, 0, 6, 0 },                        { 2, 0, 3, 8, 5 },                        { 0, 3, 0, 0, 7 },                        { 6, 8, 0, 0, 9 },                        { 0, 5, 7, 9, 0 } };     // Print the solution    primMST(graph);     return 0;} // This code is contributed by rathbhupendra
// A C program for Prim's Minimum// Spanning Tree (MST) algorithm. The program is// for adjacency matrix representation of the graph#include <limits.h>#include <stdbool.h>#include <stdio.h>// Number of vertices in the graph#define V 5 // A utility function to find the vertex with// minimum key value, from the set of vertices// not yet included in MSTint minKey(int key[], bool mstSet[]){    // Initialize min value    int min = INT_MAX, min_index;     for (int v = 0; v < V; v++)        if (mstSet[v] == false && key[v] < min)            min = key[v], min_index = v;     return min_index;} // A utility function to print the// constructed MST stored in parent[]int printMST(int parent[], int graph[V][V]){    printf("Edge \tWeight\n");    for (int i = 1; i < V; i++)        printf("%d - %d \t%d \n", parent[i], i, graph[i][parent[i]]);} // Function to construct and print MST for// a graph represented using adjacency// matrix representationvoid primMST(int graph[V][V]){    // Array to store constructed MST    int parent[V];    // Key values used to pick minimum weight edge in cut    int key[V];    // To represent set of vertices included in MST    bool mstSet[V];     // Initialize all keys as INFINITE    for (int i = 0; i < V; i++)        key[i] = INT_MAX, mstSet[i] = false;     // Always include first 1st vertex in MST.    // Make key 0 so that this vertex is picked as first vertex.    key[0] = 0;    parent[0] = -1; // First node is always root of MST     // The MST will have V vertices    for (int count = 0; count < V - 1; count++) {        // Pick the minimum key vertex from the        // set of vertices not yet included in MST        int u = minKey(key, mstSet);         // Add the picked vertex to the MST Set        mstSet[u] = true;         // Update key value and parent index of        // the adjacent vertices of the picked vertex.        // Consider only those vertices which are not        // yet included in MST        for (int v = 0; v < V; v++)             // graph[u][v] is non zero only for adjacent vertices of m            // mstSet[v] is false for vertices not yet included in MST            // Update the key only if graph[u][v] is smaller than key[v]            if (graph[u][v] && mstSet[v] == false && graph[u][v] < key[v])                parent[v] = u, key[v] = graph[u][v];    }     // print the constructed MST    printMST(parent, graph);} // driver program to test above functionint main(){    /* Let us create the following graph        2 3    (0)--(1)--(2)    | / \ |    6| 8/ \5 |7    | /     \ |    (3)-------(4)            9         */    int graph[V][V] = { { 0, 2, 0, 6, 0 },                        { 2, 0, 3, 8, 5 },                        { 0, 3, 0, 0, 7 },                        { 6, 8, 0, 0, 9 },                        { 0, 5, 7, 9, 0 } };     // Print the solution    primMST(graph);     return 0;}
// A Java program for Prim's Minimum Spanning Tree (MST) algorithm.// The program is for adjacency matrix representation of the graph import java.util.*;import java.lang.*;import java.io.*; class MST {    // Number of vertices in the graph    private static final int V = 5;     // A utility function to find the vertex with minimum key    // value, from the set of vertices not yet included in MST    int minKey(int key[], Boolean mstSet[])    {        // Initialize min value        int min = Integer.MAX_VALUE, min_index = -1;         for (int v = 0; v < V; v++)            if (mstSet[v] == false && key[v] < min) {                min = key[v];                min_index = v;            }         return min_index;    }     // A utility function to print the constructed MST stored in    // parent[]    void printMST(int parent[], int graph[][])    {        System.out.println("Edge \tWeight");        for (int i = 1; i < V; i++)            System.out.println(parent[i] + " - " + i + "\t" + graph[i][parent[i]]);    }     // Function to construct and print MST for a graph represented    // using adjacency matrix representation    void primMST(int graph[][])    {        // Array to store constructed MST        int parent[] = new int[V];         // Key values used to pick minimum weight edge in cut        int key[] = new int[V];         // To represent set of vertices included in MST        Boolean mstSet[] = new Boolean[V];         // Initialize all keys as INFINITE        for (int i = 0; i < V; i++) {            key[i] = Integer.MAX_VALUE;            mstSet[i] = false;        }         // Always include first 1st vertex in MST.        key[0] = 0; // Make key 0 so that this vertex is        // picked as first vertex        parent[0] = -1; // First node is always root of MST         // The MST will have V vertices        for (int count = 0; count < V - 1; count++) {            // Pick thd minimum key vertex from the set of vertices            // not yet included in MST            int u = minKey(key, mstSet);             // Add the picked vertex to the MST Set            mstSet[u] = true;             // Update key value and parent index of the adjacent            // vertices of the picked vertex. Consider only those            // vertices which are not yet included in MST            for (int v = 0; v < V; v++)                 // graph[u][v] is non zero only for adjacent vertices of m                // mstSet[v] is false for vertices not yet included in MST                // Update the key only if graph[u][v] is smaller than key[v]                if (graph[u][v] != 0 && mstSet[v] == false && graph[u][v] < key[v]) {                    parent[v] = u;                    key[v] = graph[u][v];                }        }         // print the constructed MST        printMST(parent, graph);    }     public static void main(String[] args)    {        /* Let us create the following graph        2 3        (0)--(1)--(2)        | / \ |        6| 8/ \5 |7        | /     \ |        (3)-------(4)            9         */        MST t = new MST();        int graph[][] = new int[][] { { 0, 2, 0, 6, 0 },                                      { 2, 0, 3, 8, 5 },                                      { 0, 3, 0, 0, 7 },                                      { 6, 8, 0, 0, 9 },                                      { 0, 5, 7, 9, 0 } };         // Print the solution        t.primMST(graph);    }}// This code is contributed by Aakash Hasija
# A Python program for Prim's Minimum Spanning Tree (MST) algorithm.# The program is for adjacency matrix representation of the graph import sys # Library for INT_MAX class Graph():     def __init__(self, vertices):        self.V = vertices        self.graph = [[0 for column in range(vertices)]                    for row in range(vertices)]     # A utility function to print the constructed MST stored in parent[]    def printMST(self, parent):        print ("Edge \tWeight")        for i in range(1, self.V):            print (parent[i], "-", i, "\t", self.graph[i][parent[i]])     # A utility function to find the vertex with    # minimum distance value, from the set of vertices    # not yet included in shortest path tree    def minKey(self, key, mstSet):         # Initialize min value        min = sys.maxsize         for v in range(self.V):            if key[v] < min and mstSet[v] == False:                min = key[v]                min_index = v         return min_index     # Function to construct and print MST for a graph    # represented using adjacency matrix representation    def primMST(self):         # Key values used to pick minimum weight edge in cut        key = [sys.maxsize] * self.V        parent = [None] * self.V # Array to store constructed MST        # Make key 0 so that this vertex is picked as first vertex        key[0] = 0        mstSet = [False] * self.V         parent[0] = -1 # First node is always the root of         for cout in range(self.V):             # Pick the minimum distance vertex from            # the set of vertices not yet processed.            # u is always equal to src in first iteration            u = self.minKey(key, mstSet)             # Put the minimum distance vertex in            # the shortest path tree            mstSet[u] = True             # Update dist value of the adjacent vertices            # of the picked vertex only if the current            # distance is greater than new distance and            # the vertex in not in the shortest path tree            for v in range(self.V):                 # graph[u][v] is non zero only for adjacent vertices of m                # mstSet[v] is false for vertices not yet included in MST                # Update the key only if graph[u][v] is smaller than key[v]                if self.graph[u][v] > 0 and mstSet[v] == False and key[v] > self.graph[u][v]:                        key[v] = self.graph[u][v]                        parent[v] = u         self.printMST(parent) g = Graph(5)g.graph = [ [0, 2, 0, 6, 0],            [2, 0, 3, 8, 5],            [0, 3, 0, 0, 7],            [6, 8, 0, 0, 9],            [0, 5, 7, 9, 0]] g.primMST(); # Contributed by Divyanshu Mehta
// A C# program for Prim's Minimum// Spanning Tree (MST) algorithm.// The program is for adjacency// matrix representation of the graphusing System;class MST {     // Number of vertices in the graph    static int V = 5;     // A utility function to find    // the vertex with minimum key    // value, from the set of vertices    // not yet included in MST    static int minKey(int[] key, bool[] mstSet)    {         // Initialize min value        int min = int.MaxValue, min_index = -1;         for (int v = 0; v < V; v++)            if (mstSet[v] == false && key[v] < min) {                min = key[v];                min_index = v;            }         return min_index;    }     // A utility function to print    // the constructed MST stored in    // parent[]    static void printMST(int[] parent, int[, ] graph)    {        Console.WriteLine("Edge \tWeight");        for (int i = 1; i < V; i++)            Console.WriteLine(parent[i] + " - " + i + "\t" + graph[i, parent[i]]);    }     // Function to construct and    // print MST for a graph represented    // using adjacency matrix representation    static void primMST(int[, ] graph)    {         // Array to store constructed MST        int[] parent = new int[V];         // Key values used to pick        // minimum weight edge in cut        int[] key = new int[V];         // To represent set of vertices        // included in MST        bool[] mstSet = new bool[V];         // Initialize all keys        // as INFINITE        for (int i = 0; i < V; i++) {            key[i] = int.MaxValue;            mstSet[i] = false;        }         // Always include first 1st vertex in MST.        // Make key 0 so that this vertex is        // picked as first vertex        // First node is always root of MST        key[0] = 0;        parent[0] = -1;         // The MST will have V vertices        for (int count = 0; count < V - 1; count++) {             // Pick thd minimum key vertex            // from the set of vertices            // not yet included in MST            int u = minKey(key, mstSet);             // Add the picked vertex            // to the MST Set            mstSet[u] = true;             // Update key value and parent            // index of the adjacent vertices            // of the picked vertex. Consider            // only those vertices which are            // not yet included in MST            for (int v = 0; v < V; v++)                 // graph[u][v] is non zero only                // for adjacent vertices of m                // mstSet[v] is false for vertices                // not yet included in MST Update                // the key only if graph[u][v] is                // smaller than key[v]                if (graph[u, v] != 0 && mstSet[v] == false                    && graph[u, v] < key[v]) {                    parent[v] = u;                    key[v] = graph[u, v];                }        }         // print the constructed MST        printMST(parent, graph);    }     // Driver Code    public static void Main()    {         /* Let us create the following graph        2 3        (0)--(1)--(2)        | / \ |        6| 8/ \5 |7        | / \ |        (3)-------(4)            9 */         int[, ] graph = new int[, ] { { 0, 2, 0, 6, 0 },                                      { 2, 0, 3, 8, 5 },                                      { 0, 3, 0, 0, 7 },                                      { 6, 8, 0, 0, 9 },                                      { 0, 5, 7, 9, 0 } };         // Print the solution        primMST(graph);    }} // This code is contributed by anuj_67.
<script> // Number of vertices in the graphlet V = 5; // A utility function to find the vertex with// minimum key value, from the set of vertices// not yet included in MSTfunction minKey(key, mstSet){    // Initialize min value    let min = Number.MAX_VALUE, min_index;     for (let v = 0; v < V; v++)        if (mstSet[v] == false && key[v] < min)            min = key[v], min_index = v;     return min_index;} // A utility function to print the// constructed MST stored in parent[]function printMST(parent, graph){    document.write("Edge      Weight" + "<br>");    for (let i = 1; i < V; i++)        document.write(parent[i] + "   -  " + i + "     " + graph[i][parent[i]] + "<br>");} // Function to construct and print MST for// a graph represented using adjacency// matrix representationfunction primMST(graph){    // Array to store constructed MST    let parent = [];         // Key values used to pick minimum weight edge in cut    let key = [];         // To represent set of vertices included in MST    let mstSet = [];     // Initialize all keys as INFINITE    for (let i = 0; i < V; i++)        key[i] = Number.MAX_VALUE, mstSet[i] = false;     // Always include first 1st vertex in MST.    // Make key 0 so that this vertex is picked as first vertex.    key[0] = 0;    parent[0] = -1; // First node is always root of MST     // The MST will have V vertices    for (let count = 0; count < V - 1; count++)    {        // Pick the minimum key vertex from the        // set of vertices not yet included in MST        let u = minKey(key, mstSet);         // Add the picked vertex to the MST Set        mstSet[u] = true;         // Update key value and parent index of        // the adjacent vertices of the picked vertex.        // Consider only those vertices which are not        // yet included in MST        for (let v = 0; v < V; v++)             // graph[u][v] is non zero only for adjacent vertices of m            // mstSet[v] is false for vertices not yet included in MST            // Update the key only if graph[u][v] is smaller than key[v]            if (graph[u][v] && mstSet[v] == false && graph[u][v] < key[v])                parent[v] = u, key[v] = graph[u][v];    }     // print the constructed MST    printMST(parent, graph);} // Driver code /* Let us create the following graph    2 3    (0)--(1)--(2)    | / \ |    6| 8/ \5 |7    | / \ |    (3)-------(4)    9     */     let graph = [ [ 0, 2, 0, 6, 0 ],[ 2, 0, 3, 8, 5 ],[ 0, 3, 0, 0, 7 ],[ 6, 8, 0, 0, 9 ],[ 0, 5, 7, 9, 0 ] ]; // Print the solutionprimMST(graph);  // This code is contributed by Dharanendra L V.</script>
Output: 
Edge   Weight
0 - 1    2
1 - 2    3
0 - 3    6
1 - 4    5
The Time Complexity of the above program is O(V^2). If the input graph is represented using adjacency list, then the time complexity of Prim’s algorithm can be reduced to O(E log V) with the help of a binary heap.  In this implementation, we are always considering the spanning tree to start from the root of the graph, and this is the basic difference between Kruskal’s Minimum Spanning Tree and Prim’s Minimum Spanning tree.
 Please see Prim’s MST for Adjacency List Representation for more details.  
Prim's Algorithm for MST(with Code Walkthrough) | GeeksforGeeks - YouTubeGeeksforGeeks529K subscribersPrim's Algorithm for MST(with Code Walkthrough) | GeeksforGeeksWatch laterShareCopy linkInfoShoppingTap to unmuteIf playback doesn't begin shortly, try restarting your device.You're signed outVideos you watch may be added to the TV's watch history and influence TV recommendations. To avoid this, cancel and sign in to YouTube on your computer.CancelConfirmMore videosMore videosSwitch cameraShareInclude playlistAn error occurred while retrieving sharing information. Please try again later.Watch on0:000:000:00 / 8:11•Live•<div class="player-unavailable"><h1 class="message">An error occurred.</h1><div class="submessage"><a href="https://www.youtube.com/watch?v=eB61LXLZVqs" target="_blank">Try watching this video on www.youtube.com</a>, or enable JavaScript if it is disabled in your browser.</div></div>
?list=PLqM7alHXFySGHRB9iQ-jxdhLUriW-V6wr
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above. 
 
vt_m
AnkurKarmakar
udkumar249
GlitchFinder
rathbhupendra
POuryaKordi
user_9781
arorakashish0911
dharanendralv23
simmytarika5
varun_b_g
AliZaidi1
amartyaghoshgfg
kumargaurav97520
geeky01adarsh
Amazon
Cisco
Minimum Spanning Tree
Prim's Algorithm.MST
Samsung
Graph
Greedy
Amazon
Samsung
Cisco
Greedy
Graph
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Breadth First Search or BFS for a Graph
Depth First Search or DFS for a Graph
Graph and its representations
Find if there is a path between two vertices in a directed graph
Topological Sorting
Program for array rotation
Write a program to print all permutations of a given string
Coin Change | DP-7
Program for Shortest Job First (or SJF) CPU Scheduling | Set 1 (Non- preemptive)
Minimum Number of Platforms Required for a Railway/Bus Station