# 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:

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
Recommended Articles
Page :