Minimum Edge Reversals So Every Node Is Reachable

Minimum Edge Reversals So Every Node Is Reachable - Problem

Imagine you have a network of cities connected by one-way roads. The network has a special property: if all roads were bidirectional, it would form a perfect tree structure with no cycles!

You're given n cities labeled from 0 to n-1 and a list of directed roads. Your mission is to find the minimum number of road reversals needed so that from each city, you can reach every other city by following the directed roads.

An edge reversal changes a road from "City A → City B" to "City B → City A".

Goal: For each starting city i, calculate independently how many roads need to be reversed to make all other cities reachable from city i.

Input: Number of cities n and array edges where edges[i] = [u, v] represents a road from city u to city v.

Output: Array where answer[i] is the minimum reversals needed when starting from city i.

Input & Output

example_1.py — Basic Tree

$ Input: n = 4, edges = [[0,1],[1,2],[3,2]]

› Output: [1, 2, 0, 1]

💡 Note: Tree: 0→1→2←3. For root 0: need to reverse 3→2 (cost 1). For root 1: need to reverse 0→1 and 3→2 (cost 2). For root 2: no reversals needed (cost 0). For root 3: need to reverse 3→2 (cost 1).

example_2.py — Linear Chain

$ Input: n = 3, edges = [[0,1],[1,2]]

› Output: [0, 1, 2]

💡 Note: Linear chain: 0→1→2. Root 0: no reversals (cost 0). Root 1: reverse 0→1 (cost 1). Root 2: reverse both 0→1 and 1→2 (cost 2).

example_3.py — Single Edge

$ Input: n = 2, edges = [[0,1]]

› Output: [0, 1]

💡 Note: Simple edge 0→1. Root 0: no reversals needed. Root 1: need to reverse 0→1 to make it 1→0.

Constraints

n == edges.length + 1
1 ≤ n ≤ 10⁵
edges[i].length == 2
0 ≤ u_i, v_i ≤ n - 1
u_i ≠ v_i
The input represents a tree (connected graph with n-1 edges)

Visualization

Tap to expand

Understanding the Visualization

Choose Initial Root

Pick node 0 as root, calculate total reversal cost via DFS

Reroot to Adjacent Node

When moving root from parent to child, adjust cost based on edge direction

Propagate Changes

Continue rerooting process through entire tree using calculated adjustments

Key Takeaway

🎯 Key Insight: Tree rerooting transforms an O(n²) problem into O(n) by calculating once and intelligently propagating changes through the tree structure.

Asked in

G Google 45 f Meta 32 a Amazon 28 ⊞ Microsoft 18

The optimal solution uses Tree Rerooting technique. First calculate the answer for one arbitrary root using DFS. Then use dynamic programming to efficiently transfer the root to all other nodes by considering how the cost changes when moving between adjacent nodes. This achieves O(n) time complexity instead of the naive O(n²) approach.

Common Approaches

Approach	Time	Space	Notes
✓ Tree Rerooting (Optimal)	O(n)	O(n)	Calculate answer for one root, then efficiently reroot using DP

Tree Rerooting (Optimal) — Algorithm Steps

Build adjacency list with both forward and reverse edges marked
Run DFS from node 0 to calculate initial answer and subtree information
Use tree rerooting: for each edge (parent, child), calculate how answer changes when moving root from parent to child
The change is: +1 if original edge was parent→child, -1 if it was child→parent
Propagate these changes through the tree to get all answers

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate Root 0

DFS from 0, count all needed reversals = 1

Reroot 0→1

Change: remove forward cost 0→1, add reverse cost 1→0

Continue Rerooting

Propagate changes through entire tree

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_N 100005

struct Edge {
    int to;
    struct Edge* next;
};

struct Edge* graph[MAX_N];
int edgeDir[MAX_N][MAX_N];
int answer[MAX_N];
int n;

void addEdge(int u, int v) {
    struct Edge* edge = malloc(sizeof(struct Edge));
    edge->to = v;
    edge->next = graph[u];
    graph[u] = edge;
}

int dfs1(int node, int parent) {
    int cost = 0;
    struct Edge* edge = graph[node];
    
    while (edge) {
        int neighbor = edge->to;
        if (neighbor != parent) {
            cost += edgeDir[node][neighbor];
            cost += dfs1(neighbor, node);
        }
        edge = edge->next;
    }
    
    return cost;
}

void dfs2(int node, int parent) {
    struct Edge* edge = graph[node];
    
    while (edge) {
        int neighbor = edge->to;
        if (neighbor != parent) {
            int oldCost = edgeDir[node][neighbor];
            int newCost = edgeDir[neighbor][node];
            answer[neighbor] = answer[node] - oldCost + newCost;
            
            dfs2(neighbor, node);
        }
        edge = edge->next;
    }
}

int* minEdgeReversals(int numNodes, int** edges, int edgesSize) {
    n = numNodes;
    
    // Initialize
    for (int i = 0; i < n; i++) {
        graph[i] = NULL;
        for (int j = 0; j < n; j++) {
            edgeDir[i][j] = -1;
        }
    }
    
    // Build graph
    for (int i = 0; i < edgesSize; i++) {
        int u = edges[i][0], v = edges[i][1];
        addEdge(u, v);
        addEdge(v, u);
        edgeDir[u][v] = 0; // Forward
        edgeDir[v][u] = 1; // Reverse
    }
    
    // Calculate answer for root 0
    answer[0] = dfs1(0, -1);
    
    // Reroot for all others
    dfs2(0, -1);
    
    int* result = malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        result[i] = answer[i];
    }
    
    return result;
}

int main() {
    int n = 4;
    int edges_data[][2] = {{0,1},{1,2},{3,2}};
    int* edges[3];
    for (int i = 0; i < 3; i++) {
        edges[i] = edges_data[i];
    }
    
    int* result = minEdgeReversals(n, edges, 3);
    
    for (int i = 0; i < n; i++) {
        printf("%d ", result[i]);
    }
    printf("\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Two DFS traversals: one to calculate initial root answer, one to reroot and calculate all other answers

✓ Linear Growth

Space Complexity

O(n)

Space for adjacency list, DFS recursion stack, and answer array

⚡ Linearithmic Space

31.5K Views

Medium-High Frequency

~25 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Tree Rerooting (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler