Given n friends and their friendship relations, find the total number of groups that exist. And the number of ways of new groups that can be formed consisting of people from every existing group.

If no relation is given for any person then that person has no group and singularly forms a group. If a is a friend of b and b is a friend of c, then a b and c form a group.

**Examples:**

Input : Number of people = 6 Relations : 1 - 2, 3 - 4 and 5 - 6 Output: Number of existing Groups = 3 Number of new groups that can be formed = 8 Explanation: The existing groups are (1, 2), (3, 4), (5, 6). The new 8 groups that can be formed by considering a member of every group are (1, 3, 5), (1, 3, 6), (1, 4, 5), (1, 4, 6), (2, 3, 5), (2, 3, 6), (2, 4, 5) and (2, 4, 6). Input: Number of people = 6 Relations : 1 - 2 and 2 - 3 Output: Number of existing Groups = 2 Number of new groups that can be formed = 3 Explanation: The existing groups are (1, 2, 3) and (4). The new groups that can be formed by considering a member of every group are (1, 4), (2, 4), (3, 4).

To count number of groups, we need to simply count connected components in the given undirected graph. Counting connected components can be easily done using DFS or BFS.

Since this is an undirected graph, the number of times a Depth First Search starts from an unvisited vertex for every friend is equal to the number of groups formed.

To count number of ways in which we form new groups can be done using simply formula which is (N1)*(N2)*….(Nn) where Ni is the no of people in i-th group.

`// CPP program to count number of existing ` `// groups and number of new groups that can ` `// be formed. ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `class` `Graph { ` ` ` `int` `V; ` `// No. of vertices ` ` ` ` ` `// Pointer to an array containing ` ` ` `// adjacency lists ` ` ` `list<` `int` `>* adj; ` ` ` ` ` `int` `countUtil(` `int` `v, ` `bool` `visited[]); ` `public` `: ` ` ` `Graph(` `int` `V); ` `// Constructor ` ` ` ` ` `// function to add an edge to graph ` ` ` `void` `addRelation(` `int` `v, ` `int` `w); ` ` ` `void` `countGroups(); ` `}; ` ` ` `Graph::Graph(` `int` `V) ` `{ ` ` ` `this` `->V = V; ` ` ` `adj = ` `new` `list<` `int` `>[V]; ` `} ` ` ` `// Adds a relation as a two way edge of ` `// undirected graph. ` `void` `Graph::addRelation(` `int` `v, ` `int` `w) ` `{ ` ` ` `// Since indexing is 0 based, reducing ` ` ` `// edge numbers by 1. ` ` ` `v--; ` ` ` `w--; ` ` ` `adj[v].push_back(w); ` ` ` `adj[w].push_back(v); ` `} ` ` ` `// Returns count of not visited nodes reachable ` `// from v using DFS. ` `int` `Graph::countUtil(` `int` `v, ` `bool` `visited[]) ` `{ ` ` ` `int` `count = 1; ` ` ` `visited[v] = ` `true` `; ` ` ` `for` `(` `auto` `i=adj[v].begin(); i!=adj[v].end(); ++i) ` ` ` `if` `(!visited[*i]) ` ` ` `count = count + countUtil(*i, visited); ` ` ` `return` `count; ` `} ` ` ` `// A DFS based function to Count number of ` `// existing groups and number of new groups ` `// that can be formed using a member of ` `// every group. ` `void` `Graph::countGroups() ` `{ ` ` ` `// Mark all the vertices as not visited ` ` ` `bool` `* visited = ` `new` `bool` `[V]; ` ` ` `memset` `(visited, 0, V*` `sizeof` `(` `int` `)); ` ` ` ` ` `int` `existing_groups = 0, new_groups = 1; ` ` ` `for` `(` `int` `i = 0; i < V; i++) ` ` ` `{ ` ` ` `// If not in any group. ` ` ` `if` `(visited[i] == ` `false` `) ` ` ` `{ ` ` ` `existing_groups++; ` ` ` ` ` `// Number of new groups that ` ` ` `// can be formed. ` ` ` `new_groups = new_groups * ` ` ` `countUtil(i, visited); ` ` ` `} ` ` ` `} ` ` ` ` ` `if` `(existing_groups == 1) ` ` ` `new_groups = 0; ` ` ` ` ` `cout << ` `"No. of existing groups are "` ` ` `<< existing_groups << endl; ` ` ` `cout << ` `"No. of new groups that can be"` ` ` `" formed are "` `<< new_groups ` ` ` `<< endl; ` `} ` ` ` `// Driver code ` `int` `main() ` `{ ` ` ` `int` `n = 6; ` ` ` ` ` `// Create a graph given in the above diagram ` ` ` `Graph g(n); ` `// total 6 people ` ` ` `g.addRelation(1, 2); ` `// 1 and 2 are friends ` ` ` `g.addRelation(3, 4); ` `// 3 and 4 are friends ` ` ` `g.addRelation(5, 6); ` `// 5 and 6 are friends ` ` ` ` ` `g.countGroups(); ` ` ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

Output:

No. of existing groups are 3 No. of new groups that can be formed are 8

Time complexity: O(N + R) where N is the the number of people and R is the number of relations.

This article is contributed by **Raj**. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

## Recommended Posts:

- Minimize Cash Flow among a given set of friends who have borrowed money from each other
- Number of Triangles in an Undirected Graph
- Number of sink nodes in a graph
- Minimum number of edges between two vertices of a Graph
- Total number of Spanning Trees in a Graph
- Count number of edges in an undirected graph
- Graph implementation using STL for competitive programming | Set 2 (Weighted graph)
- Number of shortest paths in an unweighted and directed graph
- Number of single cycle components in an undirected graph
- Total number of Spanning trees in a Cycle Graph
- Undirected graph splitting and its application for number pairs
- Maximize number of nodes which are not part of any edge in a Graph
- Program to find total number of edges in a Complete Graph
- Maximum number of edges among all connected components of an undirected graph
- Maximum number of edges to be added to a tree so that it stays a Bipartite graph