# Maximum pairs from given Graph where elements belong to different Connected Component

• Difficulty Level : Expert
• Last Updated : 14 Feb, 2022

Given a graph with N vertices numbered from 0 to (N-1) and a matrix edges[][] representing the edges of the graph, the task is to find out the maximum number of pairs that can be formed where each element of a pair belongs to different connected components of the graph.

Examples:

Input: N = 4, edges = {{1, 2}, {2, 3}}
Output: 3
Explanation: Total nodes 4 (from 0 to 3).
There are 3 possible pairs: {0, 1}, {0, 2} and {0, 3}.
No pair between {1, 2} or {1, 3} or {2, 3} because they belong to the same connected component.

graph with given edges

Input: N = 2, edges = {0, 1}
Output: 0
Explanation: All the elements belong to the same connected component.

Approach: The problem can be solved by counting the number of connected components and the number of nodes in each connected component. Total N*(N-1)/2 nodes can be formed from the given N nodes. But, to get the required number of pairs subtract the number of pairs that can be formed among the nodes of each connected component. Follow the steps mentioned below:

• Initiate total as the total number of possible pairs which is N*(N-1)/2.
• Use DFS to find the different connected components and for each component:
• Find out the number of nodes in that connected component and store that in a variable (say cnt).
• Subtract the number of pairs that can be formed by these nodes among themselves i.e. cnt*(cnt – 1)/2.
• After all the nodes are visited, the remaining value of total is the final answer.

Below is the implementation of the above approach

## C++

 `// C++ code to implement the approach``#include ``using` `namespace` `std;` `// DFS function``void` `dfs(vector<``int``> adj[], ``int` `src,``         ``bool` `visited[], ``int``& cnt)``{``    ``visited[src] = ``true``;` `    ``// Count number of nodes``    ``// in current component``    ``cnt++;``    ``for` `(``auto` `it : adj[src]) {``        ``if` `(!visited[it]) {``            ``dfs(adj, it, visited, cnt);``        ``}``    ``}``}` `// Function to count total possible pairs``int` `maxPairs(``int` `N,``             ``vector >& edges)``{``    ``vector<``int``> adj[N];` `    ``// Building the adjacency matrix``    ``for` `(``int` `i = 0; i < edges.size(); i++) {``        ``adj[edges[i][0]].push_back(``            ``edges[i][1]);``        ``adj[edges[i][1]].push_back(``            ``edges[i][0]);``    ``}` `    ``// Maximum total pairs``    ``int` `total = N * (N - 1) / 2;` `    ``// Array to keep track of components``    ``bool` `visited[N + 1] = { ``false` `};` `    ``// Loop to count total possible pairs``    ``for` `(``int` `i = 0; i < N; i++) {``        ``if` `(visited[i] == ``false``) {``            ``int` `cnt = 0;` `            ``dfs(adj, i, visited, cnt);` `            ``// Subtract pairs from``            ``// the same connected component``            ``total -= (cnt * (cnt - 1) / 2);``        ``}``    ``}``    ``return` `total;``}` `// Driver code``int` `main()``{``    ``int` `N = 4;``    ``vector > edges = { { 1, 2 },``                                   ``{ 2, 3 } };` `    ``int` `result = maxPairs(N, edges);``    ``cout << result;``    ``return` `0;``}`

## Java

 `import` `java.io.*;``import` `java.util.*;` `class` `GFG {` `  ``static` `int` `count = ``0``;` `  ``// DFS function``  ``public` `static` `void``    ``dfs(ArrayList > adj, ``int` `src,``        ``boolean` `visited[])``  ``{``    ``visited[src] = ``true``;` `    ``// Count number of nodes``    ``// in current component``    ``count++;``    ``for` `(``int` `it : adj.get(src)) {``      ``if` `(!visited[it]) {``        ``dfs(adj, it, visited);``      ``}``    ``}``  ``}` `  ``// Function to count total possible pairs``  ``public` `static` `int``    ``maxPairs(``int` `N, ArrayList > edges)``  ``{``    ``ArrayList > adj``      ``= ``new` `ArrayList >();` `    ``for` `(``int` `i = ``0``; i < N; i++) {` `      ``ArrayList temp``        ``= ``new` `ArrayList();``      ``adj.add(temp);``    ``}` `    ``// Building the adjacency matrix``    ``for` `(``int` `i = ``0``; i < edges.size(); i++) {` `      ``ArrayList temp``        ``= adj.get(edges.get(i).get(``0``));``      ``temp.add(edges.get(i).get(``1``));``      ``adj.set(edges.get(i).get(``0``), temp);` `      ``temp = adj.get(edges.get(i).get(``1``));``      ``temp.add(edges.get(i).get(``0``));``      ``adj.set(edges.get(i).get(``1``), temp);``    ``}` `    ``// Maximum total pairs``    ``int` `total = N * (N - ``1``) / ``2``;` `    ``// Array to keep track of components` `    ``boolean``[] visited = ``new` `boolean``[N + ``1``];` `    ``for` `(``int` `i = ``0``; i <= N; i++) {``      ``visited[i] = ``false``;``    ``}` `    ``// Loop to count total possible pairs``    ``for` `(``int` `i = ``0``; i < N; i++) {``      ``if` `(visited[i] == ``false``) {` `        ``count = ``0``;` `        ``dfs(adj, i, visited);` `        ``// Subtract pairs from``        ``// the same connected component``        ``total -= (count * (count - ``1``) / ``2``);``      ``}``    ``}``    ``return` `total;``  ``}``  ``// Driver code``  ``public` `static` `void` `main(String[] args)``  ``{` `    ``int` `N = ``4``;``    ``ArrayList > edges``      ``= ``new` `ArrayList >();``    ``edges.add(``      ``new` `ArrayList(Arrays.asList(``1``, ``2``)));``    ``edges.add(``      ``new` `ArrayList(Arrays.asList(``2``, ``3``)));` `    ``int` `result = maxPairs(N, edges);``    ``System.out.println(result);``  ``}``}` `// This code is contributed by Palak Gupta`

## Python3

 `# python3 code to implement the approach`  `visited ``=` `[]``cnt ``=` `0` `# DFS function`  `def` `dfs(adj, src):``    ``global` `visited``    ``global` `cnt``    ``visited[src] ``=` `True` `    ``# Count number of nodes``    ``# in current component``    ``cnt ``+``=` `1``    ``for` `it ``in` `adj[src]:``        ``if` `(``not` `visited[it]):``            ``dfs(adj, it)`  `# Function to count total possible pairs``def` `maxPairs(N, edges):``    ``global` `visited``    ``global` `cnt``    ``adj ``=` `[[] ``for` `_ ``in` `range``(N)]` `    ``# Building the adjacency matrix``    ``for` `i ``in` `range``(``0``, ``len``(edges)):``        ``adj[edges[i][``0``]].append(edges[i][``1``])``        ``adj[edges[i][``1``]].append(edges[i][``0``])` `        ``# Maximum total pairs``    ``total ``=` `(N ``*` `(N ``-` `1``)) ``/``/` `2` `    ``# Array to keep track of components``    ``for` `i ``in` `range``(N ``+` `1``):``        ``visited.append(``False``)` `        ``# Loop to count total possible pairs``    ``for` `i ``in` `range``(``0``, N):``        ``if` `(visited[i] ``=``=` `False``):``            ``cnt ``=` `0` `            ``dfs(adj, i)` `            ``# Subtract pairs from``            ``# the same connected component``            ``total ``-``=` `((cnt ``*` `(cnt ``-` `1``)) ``/``/` `2``)` `    ``return` `total`  `# Driver code``if` `__name__ ``=``=` `"__main__"``:` `    ``N ``=` `4``    ``edges ``=` `[[``1``, ``2``], [``2``, ``3``]]` `    ``result ``=` `maxPairs(N, edges)``    ``print``(result)` `    ``# This code is contributed by rakeshsahni`

## C#

 `using` `System;``using` `System.Collections.Generic;``class` `GFG``{` `  ``static` `int` `count = 0;` `  ``// DFS function``  ``public` `static` `void``    ``dfs(List> adj, ``int` `src, ``bool``[] visited)``  ``{``    ``visited[src] = ``true``;` `    ``// Count number of nodes``    ``// in current component``    ``count++;``    ``foreach` `(``int` `it ``in` `adj[src])``    ``{``      ``if` `(!visited[it])``      ``{``        ``dfs(adj, it, visited);``      ``}``    ``}``  ``}` `  ``// Function to count total possible pairs``  ``public` `static` `int``    ``maxPairs(``int` `N, List> edges)``  ``{``    ``List> adj = ``new` `List>();` `    ``for` `(``int` `i = 0; i < N; i++)``    ``{` `      ``List<``int``> temp = ``new` `List<``int``>();``      ``adj.Add(temp);``    ``}` `    ``// Building the adjacency matrix``    ``for` `(``int` `i = 0; i < edges.Count; i++)``    ``{` `      ``List<``int``> temp = adj[edges[i][0]];``      ``temp.Add(edges[i][1]);``      ``adj[edges[i][0]] = temp;` `      ``temp = adj[edges[i][1]];``      ``temp.Add(edges[i][0]);``      ``adj[edges[i][1]] = temp;``    ``}` `    ``// Maximum total pairs``    ``int` `total = N * (N - 1) / 2;` `    ``// Array to keep track of components``    ``bool``[] visited = ``new` `bool``[N + 1];` `    ``for` `(``int` `i = 0; i <= N; i++)``    ``{``      ``visited[i] = ``false``;``    ``}` `    ``// Loop to count total possible pairs``    ``for` `(``int` `i = 0; i < N; i++)``    ``{``      ``if` `(visited[i] == ``false``)``      ``{` `        ``count = 0;` `        ``dfs(adj, i, visited);` `        ``// Subtract pairs from``        ``// the same connected component``        ``total -= (count * (count - 1) / 2);``      ``}``    ``}``    ``return` `total;``  ``}``  ` `  ``// Driver code``  ``public` `static` `void` `Main()``  ``{` `    ``int` `N = 4;``    ``List> edges = ``new` `List>();``    ``edges.Add(``new` `List<``int``>());``    ``edges.Add(``new` `List<``int``>());``    ``edges[0].Add(1);``    ``edges[0].Add(2);``    ``edges[1].Add(2);``    ``edges[1].Add(3);``    ``int` `result = maxPairs(N, edges);``    ``Console.Write(result);``  ``}``}` `// This code is contributed by Saurabh Jaiswal`

## Javascript

 ``

Output

`3`

Time Complexity: O(N)
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up