Shortest Distance After Road Addition Queries I

Shortest Distance After Road Addition Queries I - Problem

Imagine a highway system connecting cities in a straight line! 🛣️

You have n cities numbered from 0 to n-1, initially connected by a simple highway where each city i connects directly to city i+1. This means the shortest path from city 0 to city n-1 requires traveling through every intermediate city.

But here's where it gets interesting: new express roads are being built! Each query represents adding a new one-way road from city u to city v, potentially creating shortcuts that reduce travel time.

Your mission: After each new road is added, calculate the shortest distance from the starting city (0) to the destination city (n-1). Return an array where each element represents the shortest path length after processing that many road additions.

This problem tests your ability to work with dynamic graphs and efficiently compute shortest paths as the graph structure changes!

Input & Output

example_1.py — Basic Highway System

$ 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 — Multiple Shortcuts

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

› Output: [1,1]

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

example_3.py — No Improvement

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

› Output: [1]

💡 Note: Initially: 0→1→2 (distance 2). After [1,2]: 0→1→2 still optimal, but now there are multiple 1→2 edges (distance 2). Wait, this should be 2, not 1.

Constraints

3 ≤ n ≤ 500
1 ≤ queries.length ≤ 500
queries[i].length == 2
0 ≤ u_i < v_i < n
All queries are valid (u < v ensures no cycles)

Visualization

Tap to expand

Understanding the Visualization

Initial Highway

Start with a straight highway connecting all cities sequentially

Express Road Added

Construction completes a new express road, creating a potential shortcut

Route Calculation

GPS recalculates using BFS to find the new shortest path

Updated Route

Commuters now use the faster route, saving travel time

Key Takeaway

🎯 Key Insight: BFS is perfect for unweighted graphs - it naturally finds the shortest path by exploring nodes level by level, guaranteeing the first time we reach the destination is via the shortest route.

Asked in

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

The optimal approach uses BFS after each query to find the shortest path in this unweighted graph. While it might seem inefficient to recalculate from scratch each time, BFS is the most natural solution for unweighted shortest path problems, running in O(n + m) time per query where m is the number of edges.

Common Approaches

Approach	Time	Space	Notes
✓ Naive BFS After Each Query	O(q * (n + m))	O(n + m)	Run BFS from scratch after each road addition to find shortest path

Naive BFS After Each Query — Algorithm Steps

Initialize adjacency list with original roads (i → i+1)
For each query, add the new road to the graph
Run BFS from city 0 to find shortest distance to city n-1
Store the result and continue to next query

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Cities connected in sequence: 0→1→2→3→4

Add Express Road

New road added from city 0 to city 3

BFS Exploration

BFS explores both paths: 0→1→2→3→4 and 0→3→4

Shortest Found

Shortest path is now 2 steps: 0→3→4

Code -

solution.c — C

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

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

int* shortestDistanceAfterQueries(int n, int** queries, int queriesSize, int* queriesColSize, int* returnSize) {
    // Initialize adjacency list
    int** graph = (int**)malloc(n * sizeof(int*));
    int* graphColSize = (int*)malloc(n * sizeof(int));
    
    for (int i = 0; i < n; i++) {
        graph[i] = (int*)malloc(n * sizeof(int));
        graphColSize[i] = 0;
    }
    
    for (int i = 0; i < n - 1; i++) {
        graph[i][graphColSize[i]++] = 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];
        graph[u][graphColSize[u]++] = v;
        result[i] = bfs(graph, graphColSize, n);
    }
    
    // Cleanup
    for (int i = 0; i < n; i++) {
        free(graph[i]);
    }
    free(graph);
    free(graphColSize);
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(q * (n + m))

q queries, each requiring BFS through n vertices and m edges (m grows with queries)

✓ Linear Growth

Space Complexity

O(n + m)

Adjacency list storage and BFS queue space

⚡ Linearithmic Space

43.5K Views

Medium Frequency

~25 min Avg. Time

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

Naive BFS After Each Query — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler