Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

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 <bits/stdc++.h>
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<pair<int, int> > 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<pair<int, int> > 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
Recommended Articles
Page :