Related Articles
Count of unique lengths of connected components for an undirected graph using STL
• Difficulty Level : Medium
• Last Updated : 05 Oct, 2020

Given an undirected graph, the task is to find the size of each connected component and print the number of unique sizes of connected components

As depicted above, the count(size of the connected component) associated with the connected components is 2, 3, and 2. Now, the unique count of the components is 2 and 3. Hence, the expected result is Count = 2
Examples:

```Input: N = 7
```

```Output: 1 2 Count = 2
3 4 5 Count = 3
6 7 Count = 2
Unique Counts of connected components: 2

Input: N = 10
```

```Output: 1 Count = 1
2 3 4 5 Count = 4
6 7 8 Count = 3
9 10 Count = 2
Unique Counts of connected components: 4
```

Prerequisites: Depth First Search
Approach:
The basic idea is to utilize the Depth First Search traversal method to keep a track of the connected components in the undirected graph. An STL container Set is used to store the unique counts of all such components since it is known that a set has the property of storing unique elements in a sorted manner. Finally, extracting the size of the Set gives us the necessary result. The step-wise implementation is as follows:

1. Initialize a hash container (Set), to store the unique counts of connected components.
2. Recursively call Depth First Search traversal.
3. For every vertex visited, store the count in the set container.
4. The final size of the Set is the required result.

Below is the implementation of the above approach:

## C++

 `// C++ program to find unique count of``// connected components``#include ``using` `namespace` `std;` `// Function to add edge in the garph``void` `add_edge(``int` `u, ``int` `v, vector<``int``> graph[])``{``    ``graph[u].push_back(v);``    ``graph[v].push_back(u);``}` `// Function to traverse the undirected graph``// using DFS algorithm and keep a track of``// individual lengths of connected chains``void` `depthFirst(``int` `v, vector<``int``> graph[],``                ``vector<``bool``>& visited, ``int``& ans)``{``    ``// Marking the visited vertex as true``    ``visited[v] = ``true``;``    ``cout << v << ``" "``;` `    ``// Incrementing the count of``    ``// connected chain length``    ``ans++;` `    ``for` `(``auto` `i : graph[v]) {``        ``if` `(visited[i] == ``false``) {``            ``// Recursive call to the DFS algorithm``            ``depthFirst(i, graph, visited, ans);``        ``}``    ``}``}` `// Function to initialize the graph``// and display the result``void` `UniqueConnectedComponent(``int` `n,``                              ``vector<``int``> graph[])``{` `    ``// Initializing boolean visited array``    ``// to mark visited vertices``    ``vector<``bool``> visited(n + 1, ``false``);` `    ``// Initializing a Set container``    ``unordered_set<``int``> result;` `    ``// Following loop invokes DFS algorithm``    ``for` `(``int` `i = 1; i <= n; i++) {``        ``if` `(visited[i] == ``false``) {``            ``// ans variable stores the``            ``// individual counts``            ``int` `ans = 0;` `            ``// DFS algorithm``            ``depthFirst(i, graph, visited, ans);` `            ``// Inserting the counts of connected``            ``// components in set``            ``result.insert(ans);``            ``cout << ``"Count = "` `<< ans << ``"\n"``;``        ``}``    ``}` `    ``cout << ``"Unique Counts of "``         ``<< ``"connected components: "``;` `    ``// The size of the Set container``    ``// gives the desired result``    ``cout << result.size() << ``"\n"``;``}` `// Driver code``int` `main()``{``    ``// Number of nodes``    ``int` `n = 7;` `    ``// Create graph``    ``vector<``int``> graph[n + 1];` `    ``// Constructing the undirected graph``    ``add_edge(1, 2, graph);``    ``add_edge(3, 4, graph);``    ``add_edge(3, 5, graph);``    ``add_edge(6, 7, graph);` `    ``// Function call``    ``UniqueConnectedComponent(n, graph);` `    ``return` `0;``}`

## Java

 `// Java program to find``// unique count of``// connected components``import` `java.util.*;``class` `GFG{` `// Function to add edge in the garph``static` `void` `add_edge(``int` `u, ``int` `v,``                     ``Vector graph[])``{``  ``graph[u].add(v);``  ``graph[v].add(u);``}` `// Function to traverse the undirected graph``// using DFS algorithm and keep a track of``// individual lengths of connected chains``static` `int` `depthFirst(``int` `v,``                      ``Vector graph[],``                      ``Vector visited,``                      ``int` `ans)``{``  ``// Marking the visited vertex as true``  ``visited.add(v, ``true``);``  ``System.out.print(v + ``" "``);` `  ``// Incrementing the count of``  ``// connected chain length``  ``ans++;` `  ``for` `(``int` `i : graph[v])``  ``{``    ``if` `(visited.get(i) == ``false``)``    ``{``      ``// Recursive call to the DFS algorithm``      ``ans = depthFirst(i, graph, visited, ans);``    ``}``  ``}``  ``return` `ans;``}` `// Function to initialize the graph``// and display the result``static` `void` `UniqueConnectedComponent(``int` `n,``                                     ``Vector graph[])``{``  ``// Initializing boolean visited array``  ``// to mark visited vertices``  ``Vector visited = ``new` `Vector<>();``  ``for``(``int` `i = ``0``; i < n + ``1``; i++)``    ``visited.add(``false``);``  ` `  ``// Initializing a Set container``  ``HashSet result = ``new` `HashSet<>();` `  ``// Following loop invokes DFS algorithm``  ``for` `(``int` `i = ``1``; i <= n; i++)``  ``{``    ``if` `(visited.get(i) == ``false``)``    ``{``      ``// ans variable stores the``      ``// individual counts``      ``int` `ans = ``0``;` `      ``// DFS algorithm``      ``ans = depthFirst(i, graph, visited, ans);` `      ``// Inserting the counts of connected``      ``// components in set``      ``result.add(ans);``      ``System.out.print(``"Count = "` `+ ``                        ``ans + ``"\n"``);``    ``}``  ``}``  ``System.out.print(``"Unique Counts of "` `+``                   ``"connected components: "``);` `  ``// The size of the Set container``  ``// gives the desired result``  ``System.out.print(result.size() + ``"\n"``);``}` `// Driver code``public` `static` `void` `main(String[] args)``{``  ``// Number of nodes``  ``int` `n = ``7``;` `  ``// Create graph``  ``Vector []graph = ``new` `Vector[n + ``1``];``  ``for` `(``int` `i = ``0``; i < graph.length; i++)``    ``graph[i] = ``new` `Vector();``  ` `  ``// Constructing the undirected graph``  ``add_edge(``1``, ``2``, graph);``  ``add_edge(``3``, ``4``, graph);``  ``add_edge(``3``, ``5``, graph);``  ``add_edge(``6``, ``7``, graph);` `  ``// Function call``  ``UniqueConnectedComponent(n, graph);``}``}` `// This code is contributed by Princi Singh`

## Python3

 `# Python3 program to find unique count of``# connected components``graph ``=` `[[] ``for` `i ``in` `range``(``100` `+` `1``)]``visited ``=` `[``False``] ``*` `(``100` `+` `1``)``ans ``=` `0` `# Function to add edge in the garph``def` `add_edge(u, v):``    ` `    ``graph[u].append(v)``    ``graph[v].append(u)` `# Function to traverse the undirected graph``# using DFS algorithm and keep a track of``# individual lengths of connected chains``def` `depthFirst(v):``    ` `    ``global` `ans``    ` `    ``# Marking the visited vertex as true``    ``visited[v] ``=` `True``    ``print``(v, end ``=` `" "``)``    ``#print(ans,end="-")` `    ``# Incrementing the count of``    ``# connected chain length``    ``ans ``+``=` `1` `    ``for` `i ``in` `graph[v]:``        ``if` `(visited[i] ``=``=` `False``):``            ` `            ``# Recursive call to the``            ``# DFS algorithm``            ``depthFirst(i)` `# Function to initialize the graph``# and display the result``def` `UniqueConnectedComponent(n):``    ` `    ``global` `ans` `    ``# Initializing boolean visited array``    ``# to mark visited vertices` `    ``# Initializing a Set container``    ``result ``=` `{}` `    ``# Following loop invokes DFS algorithm``    ``for` `i ``in` `range``(``1``, n ``+` `1``):``        ``if` `(visited[i] ``=``=` `False``):``            ` `            ``# ans variable stores the``            ``# individual counts``            ``# ans = 0` `            ``# DFS algorithm``            ``depthFirst(i)` `            ``# Inserting the counts of connected``            ``# components in set``            ``result[ans] ``=` `1``            ``print``(``"Count = "``, ans)``            ``ans ``=` `0` `    ``print``(``"Unique Counts of connected "``          ``"components: "``, end ``=` `"")` `    ``# The size of the Set container``    ``# gives the desired result``    ``print``(``len``(result))` `# Driver code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``# Number of nodes``    ``n ``=` `7` `    ``# Create graph` `    ``# Constructing the undirected graph``    ``add_edge(``1``, ``2``)``    ``add_edge(``3``, ``4``)``    ``add_edge(``3``, ``5``)``    ``add_edge(``6``, ``7``)` `    ``# Function call``    ``UniqueConnectedComponent(n)` `# This code is contributed by mohit kumar 29`

## C#

 `// C# program to find``// unique count of``// connected components``using` `System;``using` `System.Collections.Generic;``class` `GFG{` `// Function to add edge in the garph``static` `void` `add_edge(``int` `u, ``int` `v,``                     ``List<``int``> []graph)``{``  ``graph[u].Add(v);``  ``graph[v].Add(u);``}` `// Function to traverse the undirected graph``// using DFS algorithm and keep a track of``// individual lengths of connected chains``static` `int` `depthFirst(``int` `v,``                      ``List<``int``> []graph,``                      ``List visited,``                      ``int` `ans)``{``  ``// Marking the visited``  ``// vertex as true``  ``visited.Insert(v, ``true``);``  ``Console.Write(v + ``" "``);` `  ``// Incrementing the count of``  ``// connected chain length``  ``ans++;` `  ``foreach` `(``int` `i ``in` `graph[v])``  ``{``    ``if` `(visited[i] == ``false``)``    ``{``      ``// Recursive call to``      ``// the DFS algorithm``      ``ans = depthFirst(i, graph,``                       ``visited, ans);``    ``}``  ``}``  ``return` `ans;``}` `// Function to initialize the graph``// and display the result``static` `void` `UniqueConnectedComponent(``int` `n,``                                     ``List<``int``> []graph)``{``  ``// Initializing bool visited array``  ``// to mark visited vertices``  ``List visited = ``new` `List();``  ``for``(``int` `i = 0; i < n + 1; i++)``    ``visited.Add(``false``);``  ` `  ``// Initializing a Set container``  ``HashSet<``int``> result = ``new` `HashSet<``int``>();` `  ``// Following loop invokes DFS algorithm``  ``for` `(``int` `i = 1; i <= n; i++)``  ``{``    ``if` `(visited[i] == ``false``)``    ``{``      ``// ans variable stores the``      ``// individual counts``      ``int` `ans = 0;` `      ``// DFS algorithm``      ``ans = depthFirst(i, graph, visited, ans);` `      ``// Inserting the counts of connected``      ``// components in set``      ``result.Add(ans);``      ``Console.Write(``"Count = "` `+ ``                     ``ans + ``"\n"``);``    ``}``  ``}``  ``Console.Write(``"Unique Counts of "` `+``                ``"connected components: "``);` `  ``// The size of the Set container``  ``// gives the desired result``  ``Console.Write(result.Count + ``"\n"``);``}` `// Driver code``public` `static` `void` `Main(String[] args)``{``  ``// Number of nodes``  ``int` `n = 7;` `  ``// Create graph``  ``List<``int``> []graph = ``new` `List<``int``>[n + 1];``  ``for` `(``int` `i = 0; i < graph.Length; i++)``    ``graph[i] = ``new` `List<``int``>();` `  ``// Constructing the undirected graph``  ``add_edge(1, 2, graph);``  ``add_edge(3, 4, graph);``  ``add_edge(3, 5, graph);``  ``add_edge(6, 7, graph);` `  ``// Function call``  ``UniqueConnectedComponent(n, graph);``}``}` `// This code is contributed by shikhasingrajput`
Output:
```1 2 Count = 2
3 4 5 Count = 3
6 7 Count = 2
Unique Counts of connected components: 2

```

Time Complexity:
As evident from the above implementation, the graph is traversed using the Depth First Search algorithm. The individual counts are stored using Set container wherein the insertion operation takes O(1) time. The overall complexity is solely based on the time taken by the DFS algorithm to run recursively. Hence, the time complexity of the program is O(E + V) where E is the number of edges and V is the number of vertices of the graph.
Auxiliary Space: O(N)

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.

My Personal Notes arrow_drop_up