# Minimum number of reversals to reach node 0 from every other node

Given a Directed Graph with N vertices value from 0 to N – 1 and N – 1 Edges, the task is to count the number of edges must be reversed so that there is always a path from every node to node 0.

Examples:

Input: Below is the given graph Output: 0

Approach: The idea is to use BFS Traversal for a graph. Below are the steps:

1. Create a directed graph with the direction of the edges of the given graph reversed.
2. Create a queue and push node 0 in the queue.
3. During BFS Traversal on the graph do the following:
• Pop the front node(say current_node) from the queue.
• Traverse the Adjacency List of current node in the reverse graph and push in those node in the queue that are not visited.
• Traverse the Adjacency List of current node in the reverse graph and push in those node in the queue that are not visited.
• The total nodes inserted in the queue in the above steps is required count of edges to be reversed because the nodes which are connected to the current node and have not been visited yet in the graph cannot be reached to node 0, therefore, we need to reverse their direction. Add the count of the nodes in the above step to the final count.

Below is the implementation of the above approach:

 `// CPP program for the above approach ` `#include ` `using` `namespace` `std; ` ` `  `// Function to find minimum reversals ` `int` `minRev(vector > edges, ` `           ``int` `n) ` `{ ` ` `  `    ``// Add all adjacent nodes to ` `    ``// the node in the graph ` `    ``unordered_map<``int``, vector<``int``> > graph; ` `    ``unordered_map<``int``, vector<``int``> > graph_rev; ` ` `  `    ``for` `(``int` `i = 0; ` `         ``i < edges.size(); i++) { ` ` `  `        ``int` `x = edges[i]; ` `        ``int` `y = edges[i]; ` ` `  `        ``// Insert edges in the graph ` `        ``graph[x].push_back(y); ` ` `  `        ``// Insert edges in the ` `        ``// reversed graph ` `        ``graph_rev[y].push_back(x); ` `    ``} ` ` `  `    ``queue<``int``> q; ` ` `  `    ``// Create array visited to mark ` `    ``// all the visited nodes ` `    ``vector<``int``> visited(n, 0); ` `    ``q.push(0); ` ` `  `    ``// Stores the number of ` `    ``// edges to be reversed ` `    ``int` `ans = 0; ` ` `  `    ``// BFS Traversal ` `    ``while` `(!q.empty()) { ` ` `  `        ``// Pop the current node ` `        ``// from the queue ` `        ``int` `curr = q.front(); ` ` `  `        ``// mark the current ` `        ``// node visited ` `        ``visited[curr] = 1; ` ` `  `        ``// Intitialize count of edges ` `        ``// need to be reversed to 0 ` `        ``int` `count = 0; ` `        ``q.pop(); ` ` `  `        ``// Push adjacent nodes in the ` `        ``// reversed graph to the queue, ` `        ``// if not visited ` `        ``for` `(``int` `i = 0; ` `             ``i < graph_rev[curr].size(); ` `             ``i++) { ` ` `  `            ``if` `(!visited[graph_rev[curr][i]]) { ` `                ``q.push(graph_rev[curr][i]); ` `            ``} ` `        ``} ` ` `  `        ``// Push adjacent nodes in graph ` `        ``// to the queue, if not visited ` `        ``// count the number of ` `        ``// nodes added to the queue ` `        ``for` `(``int` `i = 0; ` `             ``i < graph[curr].size(); ` `             ``i++) { ` ` `  `            ``if` `(!visited[graph[curr][i]]) { ` `                ``q.push(graph[curr][i]); ` `                ``count++; ` `            ``} ` `        ``} ` ` `  `        ``// Update the reverse edge ` `        ``// to the final count ` `        ``ans += count; ` `    ``} ` ` `  `    ``// Return the result ` `    ``return` `ans; ` `} ` ` `  `// Driver Code ` `int` `main() ` `{ ` `    ``vector > edges; ` ` `  `    ``// Given edges to the graph ` `    ``edges = { { 0, 1 }, { 1, 3 }, { 2, 3 }, ` `              ``{ 4, 0 }, { 4, 5 } }; ` ` `  `    ``// Number of nodes ` `    ``int` `n = 6; ` ` `  `    ``// Function Call ` `    ``cout << minRev(edges, n); ` `    ``return` `0; ` `} `

Output:

```3
```

Time Complexity: O(V+E) where V is the number of vertices, E is the number of edges.
Auxiliary Space: O(V) where V is the number of vertices.

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.

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

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.