Reorder Routes to Make All Paths Lead to the City Zero

Reorder Routes to Make All Paths Lead to the City Zero - Problem

Imagine a country with n cities numbered from 0 to n-1, connected by exactly n-1 roads forming a tree structure (meaning there's exactly one path between any two cities). The government has decided to make all roads one-way due to narrow width constraints.

The roads are represented by connections where connections[i] = [a_i, b_i] indicates a directed road from city a_i to city b_i.

Now there's a major event happening in the capital city 0, and everyone wants to travel there! Your task is to find the minimum number of roads that need to be reversed so that every city has a path leading to city 0.

Goal: Return the minimum number of edge directions that must be changed.
Note: It's guaranteed that after reordering, every city will be able to reach city 0.

Input & Output

example_1.py — Basic Tree

$ Input: n = 6, connections = [[0,1],[1,3],[2,3],[4,0],[4,5]]

› Output: 3

💡 Note: We need to reverse 3 edges: [1,3] becomes [3,1], [2,3] becomes [3,2], and [4,5] becomes [5,4] so all cities can reach city 0.

example_2.py — Linear Chain

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

› Output: 2

💡 Note: We need to reverse 2 edges: [3,2] becomes [2,3] and [3,4] becomes [4,3] to allow all cities to reach city 0.

example_3.py — Already Optimal

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

› Output: 0

💡 Note: All roads already point toward city 0, so no reversals are needed.

Visualization

Tap to expand

Understanding the Visualization

Build undirected graph

Create adjacency list with both directions but remember original edge directions

Start DFS from city 0

Begin depth-first search from the capital city

Count wrong directions

For each edge traversed, if it was originally pointing away from city 0, increment counter

Return total count

The counter represents minimum edges to reverse

Key Takeaway

🎯 Key Insight: Instead of finding paths from each city to the capital, start from the capital and traverse the tree once, counting edges that point away from the root!

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n cities, we might traverse up to n edges to find path to city 0

⚠ Quadratic Growth

Space Complexity

O(n)

Space for visited array and recursion stack in worst case

⚡ Linearithmic Space

Constraints

2 ≤ n ≤ 5 × 10⁴
connections.length == n - 1
connections[i].length == 2
0 ≤ a_i, b_i ≤ n - 1
a_i ≠ b_i
The graph forms a tree structure (connected and acyclic)

Asked in

G Google 35 a Amazon 28 f Meta 22 ⊞ Microsoft 18

The optimal solution uses DFS from city 0 to traverse the tree and count edges pointing away from the capital. Since it's a tree structure, we can build an undirected graph but remember original directions, then perform a single DFS traversal from city 0, counting original edges that go away from the root - these are exactly the edges that need to be reversed. Time complexity: O(n), Space complexity: O(n).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Path Finding from Each City)	O(n²)	O(n)	For each city, find path to city 0 and count wrong-direction edges
DFS from Capital (Optimal)	O(n)	O(n)	Start DFS from city 0 and count edges pointing away from the capital

Brute Force (Path Finding from Each City) — Algorithm Steps

For each city i from 1 to n-1:
Perform DFS/BFS to find path from city i to city 0
Count edges that go in wrong direction along this path
Sum up all wrong-direction edges found

Visualization

Tap to expand

Step-by-Step Walkthrough

Start from city 1

City 1 explores all possible paths to reach city 0

Count wrong edges

Along the path, count edges pointing away from city 0

Repeat for all cities

Do the same process for cities 2, 3, ... n-1

Code -

solution.c — C

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

struct Edge {
    int to, cost;
};

struct Node {
    struct Edge* edges;
    int edgeCount;
    int capacity;
};

int dfsFromCity(int start, struct Node* graph, int n) {
    if (start == 0) return 0;
    
    bool* visited = (bool*)calloc(n, sizeof(bool));
    int* stack = (int*)malloc(n * 2 * sizeof(int));
    int stackSize = 0;
    
    stack[stackSize++] = start;
    stack[stackSize++] = 0; // cost
    visited[start] = true;
    
    while (stackSize > 0) {
        int cost = stack[--stackSize];
        int city = stack[--stackSize];
        
        if (city == 0) {
            free(visited);
            free(stack);
            return cost;
        }
        
        for (int i = 0; i < graph[city].edgeCount; i++) {
            int neighbor = graph[city].edges[i].to;
            int edgeCost = graph[city].edges[i].cost;
            if (!visited[neighbor]) {
                visited[neighbor] = true;
                stack[stackSize++] = neighbor;
                stack[stackSize++] = cost + edgeCost;
            }
        }
    }
    
    free(visited);
    free(stack);
    return 1000000;
}

int minReorder(int n, int** connections, int connectionsSize) {
    struct Node* graph = (struct Node*)malloc(n * sizeof(struct Node));
    
    for (int i = 0; i < n; i++) {
        graph[i].edges = (struct Edge*)malloc(10 * sizeof(struct Edge));
        graph[i].edgeCount = 0;
        graph[i].capacity = 10;
    }
    
    for (int i = 0; i < connectionsSize; i++) {
        int a = connections[i][0], b = connections[i][1];
        
        graph[a].edges[graph[a].edgeCount++] = (struct Edge){b, 1};
        graph[b].edges[graph[b].edgeCount++] = (struct Edge){a, 0};
    }
    
    int totalReversals = 0;
    bool* processed = (bool*)calloc(n, sizeof(bool));
    processed[0] = true;
    
    for (int city = 1; city < n; city++) {
        if (!processed[city]) {
            totalReversals += dfsFromCity(city, graph, n);
            processed[city] = true;
        }
    }
    
    // Cleanup
    for (int i = 0; i < n; i++) {
        free(graph[i].edges);
    }
    free(graph);
    free(processed);
    
    return totalReversals;
}

int main() {
    int n;
    scanf("%d", &n);
    int** connections = (int**)malloc((n-1) * sizeof(int*));
    for (int i = 0; i < n-1; i++) {
        connections[i] = (int*)malloc(2 * sizeof(int));
        scanf("%d %d", &connections[i][0], &connections[i][1]);
    }
    
    printf("%d\n", minReorder(n, connections, n-1));
    
    for (int i = 0; i < n-1; i++) {
        free(connections[i]);
    }
    free(connections);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n cities, we might traverse up to n edges to find path to city 0

⚠ Quadratic Growth

Space Complexity

O(n)

Space for visited array and recursion stack in worst case

⚡ Linearithmic Space

Constraints

2 ≤ n ≤ 5 × 10⁴
connections.length == n - 1
connections[i].length == 2
0 ≤ a_i, b_i ≤ n - 1
a_i ≠ b_i
The graph forms a tree structure (connected and acyclic)

42.0K Views

Medium Frequency

~15 min Avg. Time

1.8K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Path Finding from Each City) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler