Shortest Distance After Road Addition Queries II - Problem

You are given an integer n and a 2D integer array queries. There are n cities numbered from 0 to n - 1.

Initially, there is a unidirectional road from city i to city i + 1 for all 0 <= i < n - 1.

queries[i] = [u_i, v_i] represents the addition of a new unidirectional road from city u_i to city v_i.

After each query, you need to find the length of the shortest path from city 0 to city n - 1.

There are no two queries such that queries[i][0] < queries[j][0] < queries[i][1] < queries[j][1].

Return an array answer where for each i in the range [0, queries.length - 1], answer[i] is the length of the shortest path from city 0 to city n - 1 after processing the first i + 1 queries.

Input & Output

Example 1 — Basic Road Addition

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

› Output: [2]

💡 Note: Initially: 0→1→2→3→4 (distance 4). After adding road 0→3: shortest path becomes 0→3→4 (distance 2).

Example 2 — Multiple Queries

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

› Output: [2,1]

💡 Note: Initially: 0→1→2→3 (distance 3). After [0,2]: 0→2→3 (distance 2). After [1,3]: 0→2 and optimal becomes 0→2 then skip to 3 via any path giving distance 1.

Example 3 — No Improvement

$ Input: n = 3, queries = [[1,2]]

› Output: [2]

💡 Note: Initially: 0→1→2 (distance 2). Adding road 1→2 doesn't create a shortcut from 0 to 2, so distance remains 2.

Constraints

3 ≤ n ≤ 10⁵
1 ≤ queries.length ≤ 10⁵
queries[i].length = 2
0 ≤ u_i < v_i < n
There are no repeated queries

Visualization

Tap to expand

Asked in

G Google 15 f Meta 12 a Amazon 8

The key insight is that new roads create shortcuts that skip intermediate cities. Instead of running BFS after each query, maintain a skip list of reachable cities and remove those that are bypassed by shortcuts. Best approach uses Skip List Optimization with Time: O(q × n), Space: O(n).

Common Approaches

✓ BFS After Each Query

⏱️ Time: O(q × (n + q)) Space: O(n + q)

For each query, add the new road to the graph and run BFS to find the shortest path from city 0 to city n-1. This ensures we always get the correct shortest distance.

Skip List Optimization

⏱️ Time: O(q × n) Space: O(n)

Instead of rebuilding the graph each time, maintain a skip list that tracks which cities are still reachable (not skipped by shortcuts). Each new road creates a shortcut that may eliminate intermediate cities from the path.

BFS After Each Query — Algorithm Steps

Build adjacency list with initial roads
For each query, add new road to graph
Run BFS from city 0 to find distance to city n-1

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

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

Add Road

Add shortcut road from query

BFS Search

Find shortest path using level-by-level exploration

Code -

solution.c — C

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

int* solution(int n, int** queries, int queriesSize, int* returnSize) {
    int* result = (int*)malloc(queriesSize * sizeof(int));
    *returnSize = queriesSize;
    
    for (int queryIdx = 0; queryIdx < queriesSize; queryIdx++) {
        // Build adjacency list
        int** graph = (int**)malloc(n * sizeof(int*));
        int* graphSizes = (int*)calloc(n, sizeof(int));
        
        for (int i = 0; i < n; i++) {
            graph[i] = (int*)malloc(n * sizeof(int));
        }
        
        // Add initial roads
        for (int i = 0; i < n - 1; i++) {
            graph[i][graphSizes[i]++] = i + 1;
        }
        
        // Add roads from queries
        for (int i = 0; i <= queryIdx; i++) {
            int u = queries[i][0];
            int v = queries[i][1];
            graph[u][graphSizes[u]++] = v;
        }
        
        // BFS to find shortest path
        int* queue = (int*)malloc(n * sizeof(int));
        int* distance = (int*)malloc(n * sizeof(int));
        for (int i = 0; i < n; i++) {
            distance[i] = -1;
        }
        
        int front = 0, rear = 0;
        queue[rear++] = 0;
        distance[0] = 0;
        
        while (front < rear) {
            int city = queue[front++];
            
            for (int j = 0; j < graphSizes[city]; j++) {
                int neighbor = graph[city][j];
                if (distance[neighbor] == -1) {
                    distance[neighbor] = distance[city] + 1;
                    queue[rear++] = neighbor;
                }
            }
        }
        
        result[queryIdx] = distance[n-1];
        
        // Cleanup
        for (int i = 0; i < n; i++) {
            free(graph[i]);
        }
        free(graph);
        free(graphSizes);
        free(queue);
        free(distance);
    }
    
    return result;
}

int main() {
    int n;
    scanf("%d", &n);
    
    char line[10000];
    scanf(" %[^\n]", line);
    
    // Parse queries array
    int queriesSize = 0;
    int** queries = NULL;
    
    // Count queries by counting '[' after first one
    for (int i = 1; i < strlen(line); i++) {
        if (line[i] == '[') queriesSize++;
    }
    
    queries = (int**)malloc(queriesSize * sizeof(int*));
    for (int i = 0; i < queriesSize; i++) {
        queries[i] = (int*)malloc(2 * sizeof(int));
    }
    
    // Simple parsing
    char* ptr = line + 1; // Skip first '['
    for (int i = 0; i < queriesSize; i++) {
        while (*ptr != '[') ptr++;
        ptr++; // Skip '['
        queries[i][0] = strtol(ptr, &ptr, 10);
        while (*ptr != ',') ptr++;
        ptr++; // Skip ','
        queries[i][1] = strtol(ptr, &ptr, 10);
        while (*ptr != ']') ptr++;
        ptr++; // Skip ']'
    }
    
    int returnSize;
    int* result = solution(n, queries, queriesSize, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        if (i > 0) printf(",");
        printf("%d", result[i]);
    }
    printf("]\n");
    
    // Cleanup
    for (int i = 0; i < queriesSize; i++) {
        free(queries[i]);
    }
    free(queries);
    free(result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(q × (n + q))

q queries, each BFS takes O(n + edges) where edges can be up to q

✓ Linear Growth

Space Complexity

O(n + q)

Adjacency list stores n cities and up to q additional roads

⚡ Linearithmic Space

8.5K Views

Medium Frequency

~35 min Avg. Time

245 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

Shortest Distance After Road Addition Queries II - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

BFS After Each Query — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler