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

• Difficulty Level : Hard
• Last Updated : 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:
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[][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]; ` `        ``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`

## Javascript

 ``

Output:

`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)

My Personal Notes arrow_drop_up
Recommended Articles
Page :