Find weight of MST in a complete graph with edge-weights either 0 or 1 - GeeksforGeeks

24 Dec, 2021
Given an undirected weighted complete graph of N vertices. There are exactly M edges having weight 1 and rest all the possible edges have weight 0. The array arr[][] gives the set of edges having weight 1. The task is to calculate the total weight of the minimum spanning tree of this graph.
Examples: 
Input: N = 6, M = 11, arr[][] = {(1 3), (1 4), (1 5), (1 6), (2 3), (2 4), (2 5), (2 6), (3 4), (3 5), (3 6) } Output: 2 Explanation: This is the minimum spanning tree of the given graph:  
Input: N = 3, M = 0, arr[][] { } Output: 0 Explanation: This is the minimum spanning tree of the given graph:  
 
Approach: For the given graph of N nodes to be Connected Components, we need exactly N-1 edges of 1-weight edges. Following are the steps:  
Store the given graph in the map for all the edges of weight 1.Use set to store the vertices which are not included in any of the 0-weight Connected Components.For each vertex currently stored in the set, do a DFS Traversal and increase the count of Components by 1 and remove all the visited vertices during DFS Traversal from the set.During the DFS Traversal, include the 0-weight vertices in a vector and 1-weight vertices in another set. Run a DFS Traversal for all the vertices included in the vector.Then, the total weight of the minimum spanning tree is given the count of components – 1.
Store the given graph in the map for all the edges of weight 1.
Use set to store the vertices which are not included in any of the 0-weight Connected Components.
For each vertex currently stored in the set, do a DFS Traversal and increase the count of Components by 1 and remove all the visited vertices during DFS Traversal from the set.
During the DFS Traversal, include the 0-weight vertices in a vector and 1-weight vertices in another set. Run a DFS Traversal for all the vertices included in the vector.
Then, the total weight of the minimum spanning tree is given the count of components – 1.
Below is the implementation of the above approach: 
C++
Java
Python3
C#
Javascript
// C++ Program to find weight of// minimum spanning tree in a// complete graph where edges// have weight either 0 or 1#include <bits/stdc++.h>using namespace std;  // To store the edges of the given// graphmap<int, int> g[200005];set<int> s, ns;  // A utility function to perform// DFS Traversalvoid dfs(int x){    vector<int> v;    v.clear();    ns.clear();      // Check those vertices which    // are stored in the set    for (int it : s) {        // Vertices are included if        // the weight of edge is 0        if (!g[x][it]) {            v.push_back(it);        }        else {            ns.insert(it);        }    }    s = ns;    for (int i : v) {        dfs(i);    }}  // A utility function to find the// weight of Minimum Spanning Treevoid weightOfMST(int N){    // To count the connected    // components    int cnt = 0;      // Inserting the initial vertices    // in the set    for (int i = 1; i <= N; ++i) {        s.insert(i);    }      // Traversing vertices stored in    // the set and Run DFS Traversal    // for each vertices    for (; s.size();) {          // Incrementing the zero        // weight connected components        ++cnt;          int t = *s.begin();        s.erase(t);          // DFS Traversal for every        // vertex remove        dfs(t);    }      cout << cnt - 1;}  // Driver's Codeint main(){    int N = 6, M = 11;    int edges[][M] = { { 1, 3 }, { 1, 4 },                      { 1, 5 }, { 1, 6 },                      { 2, 3 }, { 2, 4 },                       { 2, 5 }, { 2, 6 },                       { 3, 4 }, { 3, 5 },                       { 3, 6 } };      // Insert edges    for (int i = 0; i < M; ++i) {        int u = edges[i][0];        int v = edges[i][1];        g[u][v] = 1;        g[v][u] = 1;    }      // Function call find the weight    // of Minimum Spanning Tree    weightOfMST(N);    return 0;}
// Java Program to find weight of // minimum spanning tree in a // complete graph where edges // have weight either 0 or 1 import java.util.*;  class GFG{  // To store the edges // of the given graphstatic HashMap<Integer,                Integer>[] g =                new HashMap[200005];static HashSet<Integer> s =                new HashSet<>();static HashSet<Integer> ns =                new HashSet<>();  // A utility function to // perform DFS Traversalstatic void dfs(int x) {  Vector<Integer> v = new Vector<>();  v.clear();  ns.clear();    // Check those vertices which  // are stored in the set  for (int it : s)   {    // Vertices are included if    // the weight of edge is 0    if (g[x].get(it) != null)     {      v.add(it);    }     else     {      ns.add(it);    }  }      s = ns;      for (int i : v)   {    dfs(i);  }}  // A utility function to find the// weight of Minimum Spanning Treestatic void weightOfMST(int N) {  // To count the connected  // components  int cnt = 0;    // Inserting the initial vertices  // in the set  for (int i = 1; i <= N; ++i)   {    s.add(i);  }    Vector<Integer> qt = new Vector<>();      for (int t : s)    qt.add(t);      // Traversing vertices stored in  // the set and Run DFS Traversal  // for each vertices  while (!qt.isEmpty())   {    // Incrementing the zero    // weight connected components    ++cnt;    int t = qt.get(0);    qt.remove(0);          // DFS Traversal for every    // vertex remove    dfs(t);  }    System.out.print(cnt - 4);}  // Driver's Codepublic static void main(String[] args) {  int N = 6, M = 11;  int edges[][] = {{1, 3}, {1, 4},                    {1, 5}, {1, 6},                    {2, 3}, {2, 4},                    {2, 5}, {2, 6},                    {3, 4}, {3, 5},                    {3, 6}};    for (int i = 0; i < g.length; i++)    g[i] = new HashMap<Integer,                        Integer>();  // Insert edges  for (int i = 0; i < M; ++i)   {    int u = edges[i][0];    int v = edges[i][1];    g[u].put(v, 1);    g[v].put(u, 1);    }    // Function call find the weight  // of Minimum Spanning Tree  weightOfMST(N);}}  // This code is contributed by gauravrajput1
# Python3 Program to find weight of# minimum spanning tree in a# complete graph where edges# have weight either 0 or 1  # To store the edges of the given# graph  g = [dict() for i in range(200005)]s = set()ns = set()   # A utility function to perform# DFS Traversaldef dfs(x):    global s, g, ns    v = []    v.clear();    ns.clear();       # Check those vertices which    # are stored in the set    for it in s:              # Vertices are included if        # the weight of edge is 0        if (x in g and not g[x][it]):            v.append(it);                  else:            ns.add(it);      s = ns;          for i in v:              dfs(i);  # A utility function to find the# weight of Minimum Spanning Treedef weightOfMST( N):      # To count the connected    # components    cnt = 0;       # Inserting the initial vertices    # in the set    for i in range(1,N + 1):              s.add(i);          # Traversing vertices stored in    # the set and Run DFS Traversal    # for each vertices    while(len(s) != 0):           # Incrementing the zero        # weight connected components        cnt += 1           t = list(s)[0]        s.discard(t);           # DFS Traversal for every        # vertex remove        dfs(t);          print(cnt)    # Driver's Codeif __name__=='__main__':          N = 6    M = 11;    edges = [ [ 1, 3 ], [ 1, 4 ],                      [ 1, 5 ], [ 1, 6 ],                      [ 2, 3 ], [ 2, 4 ],                       [ 2, 5 ], [ 2, 6 ],                       [ 3, 4 ], [ 3, 5 ],                       [ 3, 6 ] ];       # Insert edges    for i in range(M):              u = edges[i][0];        v = edges[i][1];        g[u][v] = 1;        g[v][u] = 1;           # Function call find the weight    # of Minimum Spanning Tree    weightOfMST(N);  # This code is contributed by pratham76
// C# Program to find weight of // minimum spanning tree in a // complete graph where edges // have weight either 0 or 1 using System;using System.Collections;using System.Collections.Generic; class GFG{   // To store the edges // of the given graphstatic Dictionary<int,int> [] g =  new Dictionary<int,int>[200005];static HashSet<int> s = new HashSet<int>();static HashSet<int> ns = new HashSet<int>();   // A utility function to // perform DFS Traversalstatic void dfs(int x) {  ArrayList v = new ArrayList();      ns.Clear();     // Check those vertices which  // are stored in the set  foreach (int it in s)   {    // Vertices are included if    // the weight of edge is 0    if (g[x].ContainsKey(it))     {      v.Add(it);    }     else    {      ns.Add(it);    }  }  s = ns;     foreach(int i in v)   {    dfs(i);  }}   // A utility function to find the// weight of Minimum Spanning Treestatic void weightOfMST(int N) {  // To count the connected  // components  int cnt = 0;     // Inserting the initial vertices  // in the set  for (int i = 1; i <= N; ++i)   {    s.Add(i);  }     ArrayList qt = new ArrayList();       foreach(int t in s)    qt.Add(t);       // Traversing vertices stored in  // the set and Run DFS Traversal  // for each vertices  while (qt.Count != 0)   {    // Incrementing the zero    // weight connected components    ++cnt;    int t = (int)qt[0];    qt.RemoveAt(0);           // DFS Traversal for every    // vertex remove    dfs(t);  }     Console.Write(cnt - 4);}   // Driver's Codepublic static void Main(string[] args) {  int N = 6, M = 11;  int [,]edges = {{1, 3}, {1, 4},                    {1, 5}, {1, 6},                    {2, 3}, {2, 4},                    {2, 5}, {2, 6},                    {3, 4}, {3, 5},                    {3, 6}};     for (int i = 0; i < 11; i++)    g[i] = new Dictionary<int, int>();        // Insert edges  for (int i = 0; i < M; ++i)   {    int u = edges[i, 0];    int v = edges[i, 1];    g[u][v] = 1;    g[v][u] = 1;   }     // Function call find the weight  // of Minimum Spanning Tree  weightOfMST(N);}}  // This code is contributed by rutvik_56
<script>  // Javascript program to find weight of// minimum spanning tree in a// complete graph where edges// have weight either 0 or 1  // To store the edges// of the given graphlet g = new Array(200005);for(let i = 0; i < 200005; i++)    g[i] = new Map();  let s = new Set();let ns = new Set();  // A utility function to// perform DFS Traversalfunction dfs(x){    let v = [];       // Check those vertices which    // are stored in the set    for(let it of s.values())    {                  // Vertices are included if        // the weight of edge is 0        if (g[x].get(it) != null)        {            v.push(it);        }        else        {            ns.add(it);        }    }          s = ns;          for(let i of v.values())    {        dfs(i);    }}  // A utility function to find the// weight of Minimum Spanning Treefunction weightOfMST(N){          // To count the connected    // components    let cnt = 0;          // Inserting the initial vertices    // in the set    for(let i = 1; i <= N; ++i)    {        s.add(i);    }          let qt = []          for(let t of s.values())        qt.push(t);          // Traversing vertices stored in    // the set and Run DFS Traversal    // for each vertices    while (qt.length != 0)    {                  // Incrementing the zero        // weight connected components        ++cnt;        let t = qt[0];        qt.shift();                  // DFS Traversal for every        // vertex remove        dfs(t);    }    document.write(cnt - 4);}  // Driver's Codelet N = 6, M = 11;let edges = [ [ 1, 3 ], [ 1, 4 ],              [ 1, 5 ], [ 1, 6 ],              [ 2, 3 ], [ 2, 4 ],              [ 2, 5 ], [ 2, 6 ],              [ 3, 4 ], [ 3, 5 ],              [ 3, 6 ] ];   // Insert edgesfor(let i = 0; i < M; ++i){    let u = edges[i][0];    let v = edges[i][1];    g[u].set(v, 1);    g[v].set(u, 1);}  // Function call find the weight// of Minimum Spanning TreeweightOfMST(N);  // This code is contributed by unknown2108  </script>
2
 
Time Complexity :O(N*log N + M) where N is the number of vertices and M is the number of edges.Auxiliary Space: O(N)
GauravRajput1
rutvik_56
pratham76
unknown2108
pankajsharmagfg
ashutoshsinghgeeksforgeeks
Graph Minimum Spanning Tree
Algorithms
Graph
Greedy
Recursion
Sorting
Greedy
Recursion
Sorting
Graph
Algorithms
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
DSA Sheet by Love Babbar
How to Start Learning DSA?
Difference between Algorithm, Pseudocode and Program
K means Clustering - Introduction
Types of Complexity Classes | P, NP, CoNP, NP hard and NP complete
Breadth First Search or BFS for a Graph
Dijkstra's shortest path algorithm | Greedy Algo-7
Depth First Search or DFS for a Graph
Prim’s Minimum Spanning Tree (MST) | Greedy Algo-5
Kruskal’s Minimum Spanning Tree Algorithm | Greedy Algo-2