Shortest Distance After Road Addition Queries II

Shortest Distance After Road Addition Queries II - Problem

Imagine you're a city planner managing a transportation network! You have n cities numbered from 0 to n-1, initially connected by a simple highway system where each city i has a direct road to city i+1.

Now comes the exciting part: you'll receive a series of road construction queries, where each query [u, v] represents building a new express highway from city u directly to city v. These new roads can create shortcuts that dramatically reduce travel time!

Your mission is to track how these new roads affect the shortest path from city 0 to city n-1 after each construction project. The key constraint is that the queries follow a specific pattern: no two queries will create overlapping or intersecting shortcuts.

Goal: Return an array where each element represents the shortest distance from city 0 to city n-1 after processing each query in sequence.

Input & Output

example_1.py — Basic Case

$ Input: n = 5, queries = [[2,4],[0,2],[0,4]]

› Output: [3,2,1]

💡 Note: Initially: 0→1→2→3→4 (distance 4). After [2,4]: 0→1→2→4 (distance 3). After [0,2]: 0→2→4 (distance 2). After [0,4]: 0→4 (distance 1).

example_2.py — Single Query

$ Input: n = 4, queries = [[0,3]]

› Output: [1]

💡 Note: Initially: 0→1→2→3 (distance 3). After [0,3]: 0→3 (distance 1). The direct road creates a shortcut.

example_3.py — No Improvement

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

› Output: [3,3]

💡 Note: Both queries add roads that already exist in the optimal path, so the distance remains 3.

Constraints

3 ≤ n ≤ 10⁵
1 ≤ queries.length ≤ 10⁵
queries[i].length == 2
0 ≤ queries[i][0] < queries[i][1] < n
No two queries create intersecting shortcuts
queries[i][0] ≠ 0 or queries[i][1] ≠ n - 1 for more than one query

Visualization

Tap to expand

Understanding the Visualization

Initial Highway

Cities are connected sequentially: 0→1→2→3→4

First Express Highway

Add highway 0→3, bypassing cities 1 and 2

Second Express Highway

Add highway 1→4, but optimal path is still 0→3→4

Union-Find Optimization

Track bypassed cities efficiently without recalculating entire paths

Key Takeaway

🎯 Key Insight: The non-intersecting property of queries allows us to use Union-Find to efficiently track which cities become unreachable, avoiding the need to recalculate paths from scratch.

Asked in

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

The optimal approach uses a Union-Find data structure to efficiently track which cities become unreachable when new roads are added. Since queries don't intersect, each new road from u to v makes all cities between u+1 and v-1 unreachable in the shortest path. By maintaining this information, we can calculate the new shortest distance in O(α(n)) time per query, where α is the inverse Ackermann function.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (BFS After Each Query)	O(q × (n + e))	O(n + e)	Run BFS from scratch after each road addition to find shortest path
Greedy Union Set Optimization	O(q × α(n))	O(n)	Efficiently track which cities become unreachable using Union-Find with path compression

Brute Force (BFS After Each Query) — Algorithm Steps

Initialize graph with original roads (i → i+1)
For each query [u, v]: add road u → v to graph
Run BFS from city 0 to find shortest path to city n-1
Store the path length in result array
Repeat for all queries

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Cities 0→1→2→3→4 connected sequentially

Add Road 0→3

BFS finds shortest path: 0→3→4 (distance: 2)

Add Road 1→4

BFS finds shortest path: 0→1→4 (distance: 2)

Code -

solution.c — C

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

int bfs(int** graph, int* graphSize, int n) {
    int* queue = (int*)malloc(n * sizeof(int));
    bool* visited = (bool*)calloc(n, sizeof(bool));
    int front = 0, rear = 0;
    int distance = 0;
    
    queue[rear++] = 0;
    visited[0] = true;
    
    while (front < rear) {
        int levelSize = rear - front;
        for (int i = 0; i < levelSize; i++) {
            int node = queue[front++];
            if (node == n - 1) {
                free(queue);
                free(visited);
                return distance;
            }
            
            for (int j = 0; j < graphSize[node]; j++) {
                int neighbor = graph[node][j];
                if (!visited[neighbor]) {
                    visited[neighbor] = true;
                    queue[rear++] = neighbor;
                }
            }
        }
        distance++;
    }
    
    free(queue);
    free(visited);
    return -1;
}

int* shortestDistanceAfterQueries(int n, int** queries, int queriesSize, int* queriesColSize, int* returnSize) {
    int** graph = (int**)malloc(n * sizeof(int*));
    int* graphSize = (int*)calloc(n, sizeof(int));
    int* graphCapacity = (int*)malloc(n * sizeof(int));
    
    // Initialize graph
    for (int i = 0; i < n; i++) {
        graph[i] = (int*)malloc(10 * sizeof(int));
        graphCapacity[i] = 10;
        if (i < n - 1) {
            graph[i][0] = i + 1;
            graphSize[i] = 1;
        }
    }
    
    int* result = (int*)malloc(queriesSize * sizeof(int));
    *returnSize = queriesSize;
    
    for (int i = 0; i < queriesSize; i++) {
        int u = queries[i][0], v = queries[i][1];
        if (graphSize[u] >= graphCapacity[u]) {
            graphCapacity[u] *= 2;
            graph[u] = (int*)realloc(graph[u], graphCapacity[u] * sizeof(int));
        }
        graph[u][graphSize[u]++] = v;
        result[i] = bfs(graph, graphSize, n);
    }
    
    // Cleanup
    for (int i = 0; i < n; i++) {
        free(graph[i]);
    }
    free(graph);
    free(graphSize);
    free(graphCapacity);
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(q × (n + e))

q queries × BFS complexity where e is number of edges

✓ Linear Growth

Space Complexity

O(n + e)

Graph adjacency list and BFS queue storage

⚡ Linearithmic Space

43.7K Views

High Frequency

~25 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (BFS After Each Query) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler