Given a directed graph and a node **X**. The task is to find the minimum number of edges that must be added to the graph such that any node can be reachable from the given node.

**Examples:**

Input:X = 0

Output:3

Input:X = 4

Output:1

**Approach:** First, let’s mark all the vertices reachable from **X** as good, using a simple DFS. Then, for each bad vertex (vertices which are not reachable from X) v, count the number of bad vertices reachable from v (it also can be done by simple DFS). Let this number be cnt_{v}. Now, iterate over all bad vertices in non-increasing order of cnt_{v}. For the current bad vertex v, if it is still not marked as good, run a DFS from it, marking all the reachable vertices as good, and increase the answer by 1 (in fact, we are implicitly adding the edge (s, v)). It can be proved that this solution gives an optimal answer.

Below is the implementation of the above approach:

`// C++ implementation of the approach ` ` ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `const` `int` `N = 5010; ` ` ` `int` `n, x; ` ` ` `vector<` `int` `> g[N]; ` ` ` `// To check if the vertex has been ` `// visited or not ` `bool` `vis[N]; ` ` ` `// To store if vertex is reachable ` `// from source or not ` `bool` `good[N]; ` ` ` `int` `cnt; ` ` ` `void` `ADD_EDGE(` `int` `u, ` `int` `v) ` `{ ` ` ` `g[u].push_back(v); ` `} ` ` ` `// Function to find all good vertices ` `void` `dfs1(` `int` `v) ` `{ ` ` ` `good[v] = ` `true` `; ` ` ` `for` `(` `auto` `to : g[v]) ` ` ` `if` `(!good[to]) ` ` ` `dfs1(to); ` `} ` ` ` `// Function to find cnt of all unreachable vertices ` `void` `dfs2(` `int` `v) ` `{ ` ` ` `vis[v] = ` `true` `; ` ` ` `++cnt; ` ` ` `for` `(` `auto` `to : g[v]) ` ` ` `if` `(!vis[to] && !good[to]) ` ` ` `dfs2(to); ` `} ` ` ` `// Function to return the minimum edges required ` `int` `Minimum_Edges() ` `{ ` ` ` ` ` `// Find all vertices reachable from the source ` ` ` `dfs1(x); ` ` ` ` ` `// To store all vertices with their cnt value ` ` ` `vector<pair<` `int` `, ` `int` `> > val; ` ` ` ` ` `for` `(` `int` `i = 0; i < n; ++i) { ` ` ` ` ` `// If vertex is bad i.e. not reachable ` ` ` `if` `(!good[i]) { ` ` ` `cnt = 0; ` ` ` `memset` `(vis, ` `false` `, ` `sizeof` `(vis)); ` ` ` ` ` `// Find cnt of this vertex ` ` ` `dfs2(i); ` ` ` `val.push_back(make_pair(cnt, i)); ` ` ` `} ` ` ` `} ` ` ` ` ` `// Sort all unreachable vertices in ` ` ` `// non-decreasing order of their cnt values ` ` ` `sort(val.begin(), val.end()); ` ` ` `reverse(val.begin(), val.end()); ` ` ` ` ` `// Find the minimum number of edges ` ` ` `// needed to be added ` ` ` `int` `ans = 0; ` ` ` `for` `(` `auto` `it : val) { ` ` ` `if` `(!good[it.second]) { ` ` ` `++ans; ` ` ` `dfs1(it.second); ` ` ` `} ` ` ` `} ` ` ` ` ` `return` `ans; ` `} ` ` ` `// Driver code ` `int` `main() ` `{ ` ` ` `// Number of nodes and source node ` ` ` `n = 5, x = 4; ` ` ` ` ` `// Add edges to the graph ` ` ` `ADD_EDGE(0, 1); ` ` ` `ADD_EDGE(1, 2); ` ` ` `ADD_EDGE(2, 3); ` ` ` `ADD_EDGE(3, 0); ` ` ` ` ` `cout << Minimum_Edges(); ` ` ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

**Output:**

1

## Recommended Posts:

- Minimum cost path from source node to destination node via an intermediate node
- Find all reachable nodes from every node present in a given set
- Shortest path with exactly k edges in a directed and weighted graph
- Assign directions to edges so that the directed graph remains acyclic
- Maximum number of edges to be added to a tree so that it stays a Bipartite graph
- Right sibling of each node in a tree given as array of edges
- Minimum number of edges between two vertices of a graph using DFS
- Minimum number of edges between two vertices of a Graph
- k'th heaviest adjacent node in a graph where each vertex has weight
- Level of Each node in a Tree from source node (using BFS)
- Count single node isolated sub-graphs in a disconnected graph
- Maximum edges that can be added to DAG so that is remains DAG
- Euler Circuit in a Directed Graph
- Clone a Directed Acyclic Graph
- Detect Cycle in a Directed Graph using BFS