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++

`// 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*

## Java

`// Java implementation of the above approach ` `import` `java.io.*; ` `import` `java.util.*; ` ` ` `class` `GFG ` `{ ` ` ` ` ` `static` `final` `int` `maxx = ` `100005` `; ` ` ` `@SuppressWarnings` `(` `"unchecked"` `) ` ` ` `static` `Vector<Integer>[] graph = ` `new` `Vector[maxx]; ` ` ` `static` `Vector<Integer> duringdfs = ` `new` `Vector<>(); ` ` ` `static` `int` `cnt = ` `0` `; ` ` ` ` ` `// Function to perform the DFS calculating the ` ` ` `// count of the elements in a connected component ` ` ` `static` `void` `dfs(` `int` `curr, ` `int` `[] visited) ` ` ` `{ ` ` ` `visited[curr] = ` `1` `; ` ` ` ` ` `// Number of nodes in this component ` ` ` `++cnt; ` ` ` ` ` `// Stores the nodes which belong ` ` ` `// to current component ` ` ` `duringdfs.add(curr); ` ` ` `for` `(` `int` `child : graph[curr]) ` ` ` `{ ` ` ` ` ` `// If the child is not visited ` ` ` `if` `(visited[child] == ` `0` `) ` ` ` `dfs(child, visited); ` ` ` `} ` ` ` `} ` ` ` ` ` `// Function to return the desired ` ` ` `// count for every node in the graph ` ` ` `static` `void` `maximumVisit(` `int` `n, ` `int` `k) ` ` ` `{ ` ` ` ` ` `// To keep track of nodes we visit ` ` ` `int` `[] visited = ` `new` `int` `[maxx]; ` ` ` ` ` `// Mark every node unvisited ` ` ` `Arrays.fill(visited, ` `0` `); ` ` ` ` ` `int` `[] ans = ` `new` `int` `[maxx]; ` ` ` ` ` `// No of connected elements for each node ` ` ` `Arrays.fill(ans, ` `0` `); ` ` ` ` ` `for` `(` `int` `i = ` `1` `; i <= n; i++) ` ` ` `{ ` ` ` `duringdfs.clear(); ` ` ` ` ` `// 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, visited); ` ` ` `} ` ` ` ` ` `// Now store the count of all the visited ` ` ` `// nodes for any particular component. ` ` ` `for` `(` `int` `x : duringdfs) ` ` ` `ans[x] = cnt; ` ` ` `} ` ` ` ` ` `// Print the result ` ` ` `for` `(` `int` `i = ` `1` `; i <= n; i++) ` ` ` `System.out.print(ans[i] + ` `" "` `); ` ` ` `System.out.println(); ` ` ` `return` `; ` ` ` `} ` ` ` ` ` `// Function to build the graph ` ` ` `static` `void` `makeGraph() ` ` ` `{ ` ` ` `// Initializing graph ` ` ` `for` `(` `int` `i = ` `0` `; i < maxx; i++) ` ` ` `graph[i] = ` `new` `Vector<>(); ` ` ` ` ` `graph[` `1` `].add(` `2` `); ` ` ` `graph[` `2` `].add(` `1` `); ` ` ` `graph[` `2` `].add(` `3` `); ` ` ` `graph[` `3` `].add(` `2` `); ` ` ` `graph[` `3` `].add(` `4` `); ` ` ` `graph[` `4` `].add(` `3` `); ` ` ` `graph[` `5` `].add(` `6` `); ` ` ` `graph[` `6` `].add(` `5` `); ` ` ` `graph[` `6` `].add(` `7` `); ` ` ` `graph[` `7` `].add(` `6` `); ` ` ` `graph[` `5` `].add(` `7` `); ` ` ` `graph[` `7` `].add(` `5` `); ` ` ` `} ` ` ` ` ` `// Driver Code ` ` ` `public` `static` `void` `main(String[] args) ` ` ` `{ ` ` ` `int` `N = ` `7` `, K = ` `6` `; ` ` ` ` ` `// Build the graph ` ` ` `makeGraph(); ` ` ` ` ` `maximumVisit(N, K); ` ` ` `} ` `} ` ` ` `// This code is contributed by ` `// sanjeev2552 ` |

*chevron_right*

*filter_none*

**Output:**

4 4 4 4 3 3 3

** Time Complexity : ** 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.

## Recommended Posts:

- Maximum number of edges that N-vertex graph can have such that graph is Triangle free | Mantel's Theorem
- Kth largest node among all directly connected nodes to the given node in an undirected graph
- Minimum edges to be added in a directed graph so that any node can be reachable from a given node
- Maximize number of nodes which are not part of any edge in a Graph
- Detect cycle in the graph using degrees of nodes of graph
- Paths to travel each nodes using each edge (Seven Bridges of Königsberg)
- Maximize count of nodes disconnected from all other nodes in a Graph
- k'th heaviest adjacent node in a graph where each vertex has weight
- Count the nodes of the tree which make a pangram when concatenated with the sub-tree nodes
- Minimum nodes to be colored in a Graph such that every node has a colored neighbour
- Print node whose each neighboring Tree has all nodes of same color
- Find the maximum component size after addition of each edge to the graph
- Maximum sum of values of nodes among all connected components of an undirected graph
- Print levels with odd number of nodes and even number of nodes
- Level of Each node in a Tree from source node (using BFS)
- Farthest distance of a Node from each Node of a Tree
- Number of sink nodes in a graph
- Calculate number of nodes between two vertices in an acyclic Graph by Disjoint Union method
- Calculate number of nodes between two vertices in an acyclic Graph by DFS method
- Sum of the distances from every node to all other nodes is maximum

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.