# Queries to check if vertices X and Y are in the same Connected Component of an Undirected Graph

• Last Updated : 24 Mar, 2021

Given an undirected graph consisting of N vertices and M edges and queries Q[][] of the type {X, Y}, the task is to check if the vertices X and Y are in the same connected component of the Graph.

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: Q[][] = {{1, 5}, {3, 2}, {5, 2}}
Graph:

```1-3-4   2
|
5   ```

Output: Yes No No
Explanation:
From the given graph, it can be observed that the vertices {1, 5} are in the same connected component.
But {3, 2} and {5, 2} are from different components.
Input: Q[][] = {{1, 9}, {2, 8}, {3, 5}, {7, 9}}
Graph:

```1-3-4  2-5-6  7-9
|
8   ```

Output: No Yes No Yes
Explanation:
From the given graph, it can be observed that the vertices {2, 8} and {7, 9} is from same connected component.
But {1, 9} and {3, 5} are from different components.

Approach: The idea is to use the Disjoint Set-Union to solve the problem. The basic interface of the Disjoint set union data structure used is as follows:

• make_set(v): To create a new set consisting of the new element v.
• find_set(v): Returns the representative of the set that contains the element v. This is optimized using Path Compression.
• union_set(a, b): Merges the two specified sets (the set in which the element is located, and the set in which the element b is located). Two connected vertices are merged to form a single set(Connected Components).
• Initially, all the vertices will be a different set (i.e parent of itself ) and are formed using make_set function.
• The vertices will be merged if two of them are connected using union_set function.
• Now, for each query, use the find_set function to check if the given two vertices are from the same set or not.

Below is the implementation of the above approach:

## C++

 `// C++ Program to implement``// the above approach``#include ``using` `namespace` `std;` `// Maximum number of nodes or``// vertices that can be present``// in the graph``#define MAX_NODES 100005` `// Store the parent of each vertex``int` `parent[MAX_NODES];` `// Stores the size of each set``int` `size_set[MAX_NODES];` `// Function to initialize the``// parent of each vertices``void` `make_set(``int` `v)``{``    ``parent[v] = v;``    ``size_set[v] = 1;``}` `// Function to find the representative``// of the set which contain element v``int` `find_set(``int` `v)``{``    ``if` `(v == parent[v])``        ``return` `v;` `    ``// Path compression technique to``    ``// optimize the time complexity``    ``return` `parent[v]``           ``= find_set(parent[v]);``}` `// Function to merge two different set``// into a single set by finding the``// representative of each set and merge``// the smallest set with the larger one``void` `union_set(``int` `a, ``int` `b)``{` `    ``// Finding the set representative``    ``// of each element``    ``a = find_set(a);``    ``b = find_set(b);` `    ``// Check if they have different set``    ``// repersentative``    ``if` `(a != b) {` `        ``// Compare the set sizes``        ``if` `(size_set[a] < size_set[b])``            ``swap(a, b);` `        ``// Assign parent of smaller set``        ``// to the larger one``        ``parent[b] = a;` `        ``// Add the size of smaller set``        ``// to the larger one``        ``size_set[a] += size_set[b];``    ``}``}` `// Function to check the vertices``// are on the same set or not``string check(``int` `a, ``int` `b)``{``    ``a = find_set(a);``    ``b = find_set(b);` `    ``// Check if they have same``    ``// set representative or not``    ``return` `(a == b) ? ``"Yes"` `: ``"No"``;``}` `// Driver Code``int` `main()``{``    ``int` `n = 5, m = 3;` `    ``make_set(1);``    ``make_set(2);``    ``make_set(3);``    ``make_set(4);``    ``make_set(5);` `    ``// Connected vertices and taking``    ``// them into single set``    ``union_set(1, 3);``    ``union_set(3, 4);``    ``union_set(3, 5);` `    ``// Number of queries``    ``int` `q = 3;` `    ``// Function call``    ``cout << check(1, 5) << endl;``    ``cout << check(3, 2) << endl;``    ``cout << check(5, 2) << endl;` `    ``return` `0;``}`

## Java

 `// Java Program to implement``// the above approach``import` `java.util.*;``class` `GFG{` `// Maximum number of nodes or``// vertices that can be present``// in the graph``static` `final` `int` `MAX_NODES = ``100005``;` `// Store the parent of each vertex``static` `int` `[]parent = ``new` `int``[MAX_NODES];` `// Stores the size of each set``static` `int` `[]size_set = ``new` `int``[MAX_NODES];` `// Function to initialize the``// parent of each vertices``static` `void` `make_set(``int` `v)``{``    ``parent[v] = v;``    ``size_set[v] = ``1``;``}` `// Function to find the representative``// of the set which contain element v``static` `int` `find_set(``int` `v)``{``    ``if` `(v == parent[v])``        ``return` `v;` `    ``// Path compression technique to``    ``// optimize the time complexity``    ``return` `parent[v] = find_set(parent[v]);``}` `// Function to merge two different set``// into a single set by finding the``// representative of each set and merge``// the smallest set with the larger one``static` `void` `union_set(``int` `a, ``int` `b)``{` `    ``// Finding the set representative``    ``// of each element``    ``a = find_set(a);``    ``b = find_set(b);` `    ``// Check if they have different set``    ``// repersentative``    ``if` `(a != b) {` `        ``// Compare the set sizes``        ``if` `(size_set[a] < size_set[b])``        ``{``            ``a = a+b;``            ``b = a-b;``            ``a = a-b;``        ``}` `        ``// Assign parent of smaller set``        ``// to the larger one``        ``parent[b] = a;` `        ``// Add the size of smaller set``        ``// to the larger one``        ``size_set[a] += size_set[b];``    ``}``}` `// Function to check the vertices``// are on the same set or not``static` `String check(``int` `a, ``int` `b)``{``    ``a = find_set(a);``    ``b = find_set(b);` `    ``// Check if they have same``    ``// set representative or not``    ``return` `(a == b) ? ``"Yes"` `: ``"No"``;``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``int` `n = ``5``, m = ``3``;` `    ``make_set(``1``);``    ``make_set(``2``);``    ``make_set(``3``);``    ``make_set(``4``);``    ``make_set(``5``);` `    ``// Connected vertices and taking``    ``// them into single set``    ``union_set(``1``, ``3``);``    ``union_set(``3``, ``4``);``    ``union_set(``3``, ``5``);` `    ``// Number of queries``    ``int` `q = ``3``;` `    ``// Function call``    ``System.out.print(check(``1``, ``5``) + ``"\n"``);``    ``System.out.print(check(``3``, ``2``) + ``"\n"``);``    ``System.out.print(check(``5``, ``2``) + ``"\n"``);``}``}` `// This code is contributed by Rohit_ranjan`

## Python3

 `# Python3 Program to implement``# the above approach` `# Maximum number of nodes or``# vertices that can be present``# in the graph``MAX_NODES ``=` `100005`` ` `# Store the parent of each vertex``parent ``=` `[``0` `for` `i ``in` `range``(MAX_NODES)];`` ` `# Stores the size of each set``size_set ``=` `[``0` `for` `i ``in` `range``(MAX_NODES)];`` ` `# Function to initialize the``# parent of each vertices``def` `make_set(v):``    ` `    ``parent[v] ``=` `v;``    ``size_set[v] ``=` `1``;`` ` `# Function to find the``# representative of the``# set which contain element v``def` `find_set(v):` `    ``if` `(v ``=``=` `parent[v]):``        ``return` `v;`` ` `    ``# Path compression technique to``    ``# optimize the time complexity``    ``parent[v] ``=` `find_set(parent[v]);``    ` `    ``return` `parent[v]`` ` `# Function to merge two``# different set into a``# single set by finding the``# representative of each set``# and merge the smallest set``# with the larger one``def` `union_set(a, b):`` ` `    ``# Finding the set``    ``# representative``    ``# of each element``    ``a ``=` `find_set(a);``    ``b ``=` `find_set(b);`` ` `    ``# Check if they have``    ``# different set``    ``# repersentative``    ``if` `(a !``=` `b):`` ` `        ``# Compare the set sizes``        ``if` `(size_set[a] <``            ``size_set[b]):``            ``swap(a, b);`` ` `        ``# Assign parent of``        ``# smaller set to``        ``# the larger one``        ``parent[b] ``=` `a;`` ` `        ``# Add the size of smaller set``        ``# to the larger one``        ``size_set[a] ``+``=` `size_set[b];`` ` `# Function to check the vertices``# are on the same set or not``def` `check(a, b):` `    ``a ``=` `find_set(a);``    ``b ``=` `find_set(b);`` ` `    ``# Check if they have same``    ``# set representative or not``    ``if` `a ``=``=` `b:``        ``return` `(``"Yes"``)``    ``else``:``        ``return` `(``"No"``)` `# Driver code     ``if` `__name__``=``=``"__main__"``:``    ` `    ``n ``=` `5``    ``m ``=` `3``;`` ` `    ``make_set(``1``);``    ``make_set(``2``);``    ``make_set(``3``);``    ``make_set(``4``);``    ``make_set(``5``);`` ` `    ``# Connected vertices``    ``# and taking them``    ``# into single set``    ``union_set(``1``, ``3``);``    ``union_set(``3``, ``4``);``    ``union_set(``3``, ``5``);`` ` `    ``# Number of queries``    ``q ``=` `3``;`` ` `    ``# Function call``    ``print``(check(``1``, ``5``))``    ``print``(check(``3``, ``2``))``    ``print``(check(``5``, ``2``))` `# This code is contributed by rutvik_56`

## C#

 `// C# program to implement``// the above approach``using` `System;` `class` `GFG{` `// Maximum number of nodes or``// vertices that can be present``// in the graph``static` `readonly` `int` `MAX_NODES = 100005;` `// Store the parent of each vertex``static` `int` `[]parent = ``new` `int``[MAX_NODES];` `// Stores the size of each set``static` `int` `[]size_set = ``new` `int``[MAX_NODES];` `// Function to initialize the``// parent of each vertices``static` `void` `make_set(``int` `v)``{``    ``parent[v] = v;``    ``size_set[v] = 1;``}` `// Function to find the representative``// of the set which contain element v``static` `int` `find_set(``int` `v)``{``    ``if` `(v == parent[v])``        ``return` `v;` `    ``// Path compression technique to``    ``// optimize the time complexity``    ``return` `parent[v] = find_set(parent[v]);``}` `// Function to merge two different set``// into a single set by finding the``// representative of each set and merge``// the smallest set with the larger one``static` `void` `union_set(``int` `a, ``int` `b)``{` `    ``// Finding the set representative``    ``// of each element``    ``a = find_set(a);``    ``b = find_set(b);` `    ``// Check if they have different set``    ``// repersentative``    ``if` `(a != b)``    ``{``        ` `        ``// Compare the set sizes``        ``if` `(size_set[a] < size_set[b])``        ``{``            ``a = a + b;``            ``b = a - b;``            ``a = a - b;``        ``}` `        ``// Assign parent of smaller set``        ``// to the larger one``        ``parent[b] = a;` `        ``// Add the size of smaller set``        ``// to the larger one``        ``size_set[a] += size_set[b];``    ``}``}` `// Function to check the vertices``// are on the same set or not``static` `String check(``int` `a, ``int` `b)``{``    ``a = find_set(a);``    ``b = find_set(b);` `    ``// Check if they have same``    ``// set representative or not``    ``return` `(a == b) ? ``"Yes"` `: ``"No"``;``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``    ``//int n = 5, m = 3;` `    ``make_set(1);``    ``make_set(2);``    ``make_set(3);``    ``make_set(4);``    ``make_set(5);` `    ``// Connected vertices and taking``    ``// them into single set``    ``union_set(1, 3);``    ``union_set(3, 4);``    ``union_set(3, 5);` `    ``// Number of queries``    ``//int q = 3;` `    ``// Function call``    ``Console.Write(check(1, 5) + ``"\n"``);``    ``Console.Write(check(3, 2) + ``"\n"``);``    ``Console.Write(check(5, 2) + ``"\n"``);``}``}` `// This code is contributed by Amit Katiyar`

## Javascript

 ``
Output:
```Yes
No
No```

Time Complexity: O(N + M + sizeof(Q))
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up