Skip to content
Related Articles
Find weight of MST in a complete graph with edge-weights either 0 or 1
• Last Updated : 11 Dec, 2020

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:
Explanation:
This is the minimum spanning tree of the given graph: Input: N = 3, M = 0, arr[][] { }
Output:
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:

1. Store the given graph in the map for all the edges of weight 1.
2. Use set to store the vertices which are not included in any of the 0-weight Connected Components.
3. 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.
4. 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.
5. 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++

 `// C++ Program to find weight of``// minimum spanning tree in a``// complete graph where edges``// have weight either 0 or 1``#include ``using` `namespace` `std;` `// To store the edges of the given``// graph``map<``int``, ``int``> g;``set<``int``> s, ns;` `// A utility function to perform``// DFS Traversal``void` `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 Tree``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.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 Code``int` `main()``{``    ``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 } };` `    ``// Insert edges``    ``for` `(``int` `i = 0; i < M; ++i) {``        ``int` `u = edges[i];``        ``int` `v = edges[i];``        ``g[u][v] = 1;``        ``g[v][u] = 1;``    ``}` `    ``// Function call find the weight``    ``// of Minimum Spanning Tree``    ``weightOfMST(N);``    ``return` `0;``}`

## Java

 `// 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 graph``static` `HashMap[] g =``               ``new` `HashMap[``200005``];``static` `HashSet s =``               ``new` `HashSet<>();``static` `HashSet ns =``               ``new` `HashSet<>();` `// A utility function to``// perform DFS Traversal``static` `void` `dfs(``int` `x)``{``  ``Vector 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 Tree``static` `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 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 Code``public` `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();``  ``// 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

 `# 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 Traversal``def` `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 Tree``def` `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 Code``if` `__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#

 `// 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 graph``static` `Dictionary<``int``,``int``> [] g =  ``new` `Dictionary<``int``,``int``>;``static` `HashSet<``int``> s = ``new` `HashSet<``int``>();``static` `HashSet<``int``> ns = ``new` `HashSet<``int``>();`` ` `// A utility function to``// perform DFS Traversal``static` `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 Tree``static` `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;``    ``qt.RemoveAt(0);``     ` `    ``// DFS Traversal for every``    ``// vertex remove``    ``dfs(t);``  ``}`` ` `  ``Console.Write(cnt - 4);``}`` ` `// Driver's Code``public` `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`
Output:
`2`

Time Complexity :O(N*log N + M) where N is the number of vertices and M is the number of edges.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer Geeks Classes Live

My Personal Notes arrow_drop_up