# Maximum number of nodes which can be reached from each node in a graph.

Given a graph with N nodes and K bidirectional edges between them find the number of nodes which can be reachable from a particular. Two nodes X and Y are said to be reachable if we can start at X and end at Y using any number of edges.

**Note : A Node is reachable to itself.**

Input :N = 7 1 5 \ / \ 2 6^{__}7 \ 3 \ 4Output :4 4 4 4 3 3 3 From node 1 ,nodes {1,2,3,4} can be visited hence the answer is equal to 4 From node 5,nodes {5,6,7} can be visited. hence the answer is equal to 3. Similarly, print the count for every node.Input :N = 8 1 7 / \ \ 2 3 8 \ / \ 5 6Output :6 6 6 6 6 6 2 2

**Approach: **

To find the number of nodes reachable from a particular node, one thing to observe is that we can reach from a node X to a node Y only when they are in the same connected component.

Since the graph is bidirectional, any node in a connected component to any other node in the same connected components. Hence for a particular node X number of nodes that will be reachable will be the number of nodes in that particular component.Use depth-first search to find the answer.

Below is the implementation of the above approach:

`// C++ implementation of the above approach ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` `const` `int` `maxx = 100005; ` `vector<` `int` `> graph[maxx]; ` ` ` `// Function to perform the DFS calculating the ` `// count of the elements in a connected component ` `void` `dfs(` `int` `curr, ` `int` `& cnt, ` `int` `* ` ` ` `visited, vector<` `int` `>& duringdfs) ` `{ ` ` ` `visited[curr] = 1; ` ` ` ` ` `// Number of nodes in this component ` ` ` `++cnt; ` ` ` ` ` `// Stores the nodes which belong ` ` ` `// to current component ` ` ` `duringdfs.push_back(curr); ` ` ` `for` `(` `auto` `& child : graph[curr]) { ` ` ` ` ` `// If the child is not visited ` ` ` `if` `(visited[child] == 0) { ` ` ` `dfs(child, cnt, visited, duringdfs); ` ` ` `} ` ` ` `} ` `} ` ` ` `// Function to return the desired ` `// count for every node in the graph ` `void` `MaximumVisit(` `int` `n, ` `int` `k) ` `{ ` ` ` `// To keep track of nodes we visit ` ` ` `int` `visited[maxx]; ` ` ` ` ` `// Mark every node unvisited ` ` ` `memset` `(visited, 0, ` `sizeof` `visited); ` ` ` `int` `ans[maxx]; ` ` ` ` ` `// No of connected elements for each node ` ` ` `memset` `(ans, 0, ` `sizeof` `ans); ` ` ` `vector<` `int` `> duringdfs; ` ` ` `for` `(` `int` `i = 1; i <= n; ++i) { ` ` ` `duringdfs.clear(); ` ` ` `int` `cnt = 0; ` ` ` ` ` `// If a node is not visited, perform a DFS as ` ` ` `// this node belongs to a different component ` ` ` `// which is not yet visited ` ` ` `if` `(visited[i] == 0) { ` ` ` `cnt = 0; ` ` ` `dfs(i, cnt, visited, duringdfs); ` ` ` `} ` ` ` ` ` `// Now store the count of all the visited ` ` ` `// nodes for any particular component. ` ` ` `for` `(` `auto` `& x : duringdfs) { ` ` ` `ans[x] = cnt; ` ` ` `} ` ` ` `} ` ` ` ` ` `// Print the result ` ` ` `for` `(` `int` `i = 1; i <= n; ++i) { ` ` ` `cout << ans[i] << ` `" "` `; ` ` ` `} ` ` ` `cout << endl; ` ` ` `return` `; ` `} ` ` ` `// Function to build the graph ` `void` `MakeGraph(){ ` ` ` `graph[1].push_back(2); ` ` ` `graph[2].push_back(1); ` ` ` `graph[2].push_back(3); ` ` ` `graph[3].push_back(2); ` ` ` `graph[3].push_back(4); ` ` ` `graph[4].push_back(3); ` ` ` `graph[5].push_back(6); ` ` ` `graph[6].push_back(5); ` ` ` `graph[6].push_back(7); ` ` ` `graph[7].push_back(6); ` ` ` `graph[5].push_back(7); ` ` ` `graph[7].push_back(5); ` `} ` ` ` `// Driver code ` `int` `main() ` `{ ` ` ` `int` `N = 7, K = 6; ` ` ` ` ` `// Build the graph ` ` ` `MakeGraph(); ` ` ` ` ` `MaximumVisit(N, K); ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

**Output:**

4 4 4 4 3 3 3

** Time Complexity : ** O(N)

## Recommended Posts:

- Kth largest node among all directly connected nodes to the given node in an undirected graph
- Number of sink nodes in a graph
- Maximize number of nodes which are not part of any edge in a Graph
- Minimum edges to be added in a directed graph so that any node can be reachable from a given node
- Calculate number of nodes between two vertices in an acyclic Graph by Disjoint Union method
- Detect cycle in the graph using degrees of nodes of graph
- Maximum number of edges in Bipartite graph
- Maximum number of edges among all connected components of an undirected graph
- Level with maximum number of nodes using DFS in a N-ary tree
- Maximum number of edges to be added to a tree so that it stays a Bipartite graph
- Count all possible position that can be reached by Modified Knight
- Sum of degrees of all nodes of a undirected graph
- k'th heaviest adjacent node in a graph where each vertex has weight
- XOR of all the nodes in the sub-tree of the given node
- Count single node isolated sub-graphs in a disconnected graph

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 Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.