# Smallest vertex in the connected components of all the vertices in given undirect graph

• Difficulty Level : Medium
• Last Updated : 07 Oct, 2021

Given an undirected graph G(V, E)  consisting of2 N vertices and M edges, the task is to find the smallest vertex in the connected component of the vertex i for all values of i in the range [1, N].

Examples:

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 experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Input: N = 5, edges[] = {{1, 2}, {2, 3}, {4, 5}}
Output: 1 1 1 4 4
Explanation: The given graph can be divided into a set of two connected components, i.e, {1, 2, 3} and {4, 5}.

1. For i = 1, vertex 1 belongs to the component {1, 2, 3}. Therefore, the minimum vertex in the set is 1.
2. For i = 2, vertex 2 belongs to the component {1, 2, 3}. Therefore, the minimum vertex in the set is 1.
3. For i = 3, vertex 3 belongs to the component {1, 2, 3}. Therefore, the minimum vertex in the set is 1.
4. For i = 4, vertex 4 belongs to the component {4, 5}. Therefore, the minimum vertex in the set is 4.
5. For i = 5, vertex 5 belongs to the component {4, 5}. Therefore, the minimum vertex in the set is 4.

Input: N = 6, edges[] = {{1, 3}, {2, 4}}
Output: 1 2 1 2 5 6

Approach: The given problem can be solved efficiently with the help of Disjoint Set Union. It can be observed that the vertices connected by an edge can be united into the same set and an unordered map can be used to keep track of the smallest vertex of each of the formed sets. Below are the steps to follow:

• Implement the find_set and union_set function of the Disjoint Set Union using the approach discussed in this article where find_set(x) returns the set number containing x, and union_set(x, y) unites the set containing x with the set containing y.
• Traverse the given array edges[] and for each edge (u, v), unite the set containing u with the set containing v.
• Create an unordered map minVal, where minVal[x] stores the minimum vertex of the set containing x as an element.
• Iterate over all vertices using a variable i and for each vertex set the value of minVal[find_set(node i)] to the minimum of minVal[find_set(i)] and i.
• After completing the above steps, for each vertex, i in the range [1, N], print the value of minVal[find_set(i)] as the result.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `const` `int` `maxn = 100;` `// Stores the parent and size of the``// set of the ith element``int` `parent[maxn], Size[maxn];` `// Function to initialize the ith set``void` `make_set(``int` `v)``{``    ``parent[v] = v;``    ``Size[v] = 1;``}` `// Function to find set of ith vertex``int` `find_set(``int` `v)``{``    ``// Base Case``    ``if` `(v == parent[v]) {``        ``return` `v;``    ``}` `    ``// Recursive call to find set``    ``return` `parent[v] = find_set(``               ``parent[v]);``}` `// Function to unite the set that includes``// a and the set that includes b``void` `union_sets(``int` `a, ``int` `b)``{``    ``a = find_set(a);``    ``b = find_set(b);` `    ``// If a and b are not from same set``    ``if` `(a != b) {``        ``if` `(Size[a] < Size[b])``            ``swap(a, b);``        ``parent[b] = a;``        ``Size[a] += Size[b];``    ``}``}` `// Function to find the smallest vertex in``// the connected component of the ith``// vertex for all i in range [1, N]``void` `findMinVertex(``    ``int` `N, vector > edges)``{``    ``// Loop to initialize the ith set``    ``for` `(``int` `i = 1; i <= N; i++) {``        ``make_set(i);``    ``}` `    ``// Loop to unite all vertices connected``    ``// by edges into the same set``    ``for` `(``int` `i = 0; i < edges.size(); i++) {``        ``union_sets(edges[i].first,``                   ``edges[i].second);``    ``}` `    ``// Stores the minimum vertex value``    ``// for ith set``    ``unordered_map<``int``, ``int``> minVal;` `    ``// Loop to iterate over all vertices``    ``for` `(``int` `i = 1; i <= N; i++) {` `        ``// If current vertex does not exist``        ``// in minVal initialize it with i``        ``if` `(minVal[find_set(i)] == 0) {``            ``minVal[find_set(i)] = i;``        ``}` `        ``// Update the minimum value of``        ``// the set having the ith vertex``        ``else` `{``            ``minVal[find_set(i)]``                ``= min(minVal[find_set(i)], i);``        ``}``    ``}` `    ``// Loop to print required answer``    ``for` `(``int` `i = 1; i <= N; i++) {``        ``cout << minVal[find_set(i)] << ``" "``;``    ``}``}` `// Driver Code``int` `main()``{``    ``int` `N = 6;``    ``vector > edges``        ``= { { 1, 3 }, { 2, 4 } };``    ``findMinVertex(N, edges);` `    ``return` `0;``}`

## Python3

 `# Python 3 program for the above approach` `maxn ``=` `100` `# Stores the parent and size of the``# set of the ith element``parent ``=` `[``0``]``*``maxn``Size ``=` `[``0``]``*``maxn` `# Function to initialize the ith set`  `def` `make_set(v):``    ``parent[v] ``=` `v``    ``Size[v] ``=` `1` `# Function to find set of ith vertex`  `def` `find_set(v):``    ``# Base Case``    ``if` `(v ``=``=` `parent[v]):``        ``return` `v` `    ``# Recursive call to find set``    ``parent[v] ``=` `find_set(``        ``parent[v])``    ``return` `parent[v]` `# Function to unite the set that includes``# a and the set that includes b`  `def` `union_sets(a, b):` `    ``a ``=` `find_set(a)``    ``b ``=` `find_set(b)` `    ``# If a and b are not from same set``    ``if` `(a !``=` `b):``        ``if` `(Size[a] < Size[b]):``            ``a, b ``=` `b, a``        ``parent[b] ``=` `a``        ``Size[a] ``+``=` `Size[b]` `# Function to find the smallest vertex in``# the connected component of the ith``# vertex for all i in range [1, N]`  `def` `findMinVertex(``        ``N, edges):` `    ``# Loop to initialize the ith set``    ``for` `i ``in` `range``(``1``, N ``+` `1``):``        ``make_set(i)` `    ``# Loop to unite all vertices connected``    ``# by edges into the same set``    ``for` `i ``in` `range``(``len``(edges)):``        ``union_sets(edges[i][``0``],``                   ``edges[i][``1``])` `    ``# Stores the minimum vertex value``    ``# for ith set``    ``minVal ``=` `{}` `    ``# Loop to iterate over all vertices``    ``for` `i ``in` `range``(``1``, N ``+` `1``):` `        ``# If current vertex does not exist``        ``# in minVal initialize it with i``        ``if` `(find_set(i) ``not` `in` `minVal):``            ``minVal[find_set(i)] ``=` `i` `        ``# Update the minimum value of``        ``# the set having the ith vertex``        ``else``:``            ``minVal[find_set(i)] ``=` `min``(minVal[find_set(i)], i)` `    ``# Loop to print required answer``    ``for` `i ``in` `range``(``1``, N ``+` `1``):``        ``print``(minVal[find_set(i)], end``=``" "``)` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:` `    ``N ``=` `6``    ``edges ``=` `[[``1``, ``3``], [``2``, ``4``]]``    ``findMinVertex(N, edges)` `    ``# This code is contributed by ukasp.`
Output:
`1 2 1 2 5 6`

Time Complexity: O(N)
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up