Design Graph With Shortest Path Calculator

Design Graph With Shortest Path Calculator - Problem

Design a Dynamic Graph with Shortest Path Calculator

You need to design and implement a smart graph data structure that can handle a directed weighted graph with dynamic edge additions and efficient shortest path queries.

🎯 Your Mission:
Build a Graph class that starts with n nodes (numbered 0 to n-1) and initial edges, then supports:
• Dynamic Edge Addition: Add new weighted edges at runtime
• Shortest Path Queries: Find minimum cost path between any two nodes

⚡ Key Challenge: The graph changes over time as new edges are added, so you need to efficiently handle both updates and queries. Think about real-world scenarios like GPS navigation systems that need to calculate shortest routes while road conditions and new routes are constantly being updated!

Input Format:
• Initial edges as edges[i] = [from, to, cost]
• New edges via addEdge([from, to, cost])
• Path queries via shortestPath(node1, node2)

Output: Return the minimum cost of the shortest path, or -1 if no path exists.

Input & Output

example_1.py — Basic Operations

$ Input: Graph(4, [[0,1,4],[0,3,7],[1,2,3],[2,3,2]]) shortestPath(0, 3) → 7 addEdge([1,3,1]) shortestPath(0, 3) → 5

› Output: 7 5

💡 Note: Initially, shortest path from 0→3 is direct edge with cost 7. After adding edge 1→3 with cost 1, the new shortest path becomes 0→1→3 with total cost 4+1=5.

example_2.py — No Path Case

$ Input: Graph(3, [[0,1,2]]) shortestPath(1, 2) → -1 addEdge([1,2,5]) shortestPath(1, 2) → 5

› Output: -1 5

💡 Note: Initially no path exists from node 1 to node 2, so return -1. After adding edge 1→2, the shortest (and only) path has cost 5.

example_3.py — Same Node Query

$ Input: Graph(2, [[0,1,3]]) shortestPath(0, 0) → 0 shortestPath(1, 1) → 0

› Output: 0 0

💡 Note: Distance from any node to itself is always 0, regardless of the graph structure.

Constraints

1 ≤ n ≤ 100
0 ≤ edges.length ≤ n * (n - 1)
edges[i].length == 3
0 ≤ from_i, to_i < n
from_i ≠ to_i
1 ≤ edgeCost_i ≤ 10⁶
At most 100 calls will be made to addEdge
At most 100 calls will be made to shortestPath

Visualization

Tap to expand

Asked in

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

The optimal approach uses an adjacency list to store the graph and runs Dijkstra's algorithm for each shortest path query. Edge additions are O(1) while path queries are O((V + E) log V), making this solution ideal for dynamic graphs with frequent updates and occasional queries.

Common Approaches

✓ Brute Force (Floyd-Warshall Precomputation)

⏱️ Time: O(n³) Space: O(n²)

Store all shortest paths in a distance matrix using Floyd-Warshall algorithm. When adding an edge, recompute the entire matrix. This guarantees O(1) query time but has expensive updates.

Dijkstra's Algorithm (Optimal)

⏱️ Time: O((V + E) log V) Space: O(V + E)

Maintain an adjacency list for the graph and run Dijkstra's algorithm from the source node for each shortest path query. This is optimal for sparse graphs and when queries are less frequent than updates.

Brute Force (Floyd-Warshall Precomputation) — Algorithm Steps

Initialize distance matrix with infinity, set direct edges and diagonal to 0
Run Floyd-Warshall algorithm to find all shortest paths
For addEdge: update matrix and rerun Floyd-Warshall
For shortestPath: return matrix[node1][node2]

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial Matrix

Create n×n matrix with edges and infinity for no paths

Floyd-Warshall

Compute shortest paths using all intermediate nodes

Add Edge

Update matrix with new edge and recompute all paths

Query Path

Return distance from matrix in O(1) time

Code -

solution.c — C

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

#define INF (INT_MAX / 2)
#define MAX_LINE 10000

typedef struct {
    int n;
    int** dist;
} Graph;

Graph* graphCreate(int n, int** edges, int edgesSize) {
    Graph* g = malloc(sizeof(Graph));
    g->n = n;
    g->dist = malloc(n * sizeof(int*));
    
    for (int i = 0; i < n; i++) {
        g->dist[i] = malloc(n * sizeof(int));
        for (int j = 0; j < n; j++) {
            g->dist[i][j] = (i == j) ? 0 : INF;
        }
    }
    
    for (int i = 0; i < edgesSize; i++) {
        g->dist[edges[i][0]][edges[i][1]] = edges[i][2];
    }
    
    // Floyd-Warshall
    for (int k = 0; k < n; k++) {
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if (g->dist[i][k] + g->dist[k][j] < g->dist[i][j]) {
                    g->dist[i][j] = g->dist[i][k] + g->dist[k][j];
                }
            }
        }
    }
    
    return g;
}

void graphAddEdge(Graph* g, int* edge) {
    g->dist[edge[0]][edge[1]] = edge[2];
    
    for (int k = 0; k < g->n; k++) {
        for (int i = 0; i < g->n; i++) {
            for (int j = 0; j < g->n; j++) {
                if (g->dist[i][k] + g->dist[k][j] < g->dist[i][j]) {
                    g->dist[i][j] = g->dist[i][k] + g->dist[k][j];
                }
            }
        }
    }
}

int graphShortestPath(Graph* g, int node1, int node2) {
    return g->dist[node1][node2] >= INF ? -1 : g->dist[node1][node2];
}

int main() {
    int n;
    char edgesStr[MAX_LINE], operationsStr[MAX_LINE];
    
    scanf("%d", &n);
    getchar();
    fgets(edgesStr, MAX_LINE, stdin);
    fgets(operationsStr, MAX_LINE, stdin);
    
    // Parse edges
    static int edges[1000][3];
    int edgesSize = 0;
    
    if (strcmp(edgesStr, "[]\n") != 0) {
        char* ptr = edgesStr;
        while (*ptr) {
            if (*ptr >= '0' && *ptr <= '9') {
                edges[edgesSize][0] = strtol(ptr, &ptr, 10);
                while (*ptr < '0' || *ptr > '9') ptr++;
                edges[edgesSize][1] = strtol(ptr, &ptr, 10);
                while (*ptr < '0' || *ptr > '9') ptr++;
                edges[edgesSize][2] = strtol(ptr, &ptr, 10);
                edgesSize++;
            } else {
                ptr++;
            }
        }
    }
    
    int* edgePtrs[1000];
    for (int i = 0; i < edgesSize; i++) {
        edgePtrs[i] = edges[i];
    }
    
    Graph* graph = graphCreate(n, edgePtrs, edgesSize);
    
    static char results[10000];
    results[0] = '\0';
    int first = 1;
    
    char* ptr = operationsStr;
    while (*ptr) {
        if (strncmp(ptr, "shortestPath", 12) == 0) {
            ptr += 12;
            while (*ptr < '0' || *ptr > '9') ptr++;
            int node1 = strtol(ptr, &ptr, 10);
            while (*ptr < '0' || *ptr > '9') ptr++;
            int node2 = strtol(ptr, &ptr, 10);
            
            int result = graphShortestPath(graph, node1, node2);
            if (!first) strcat(results, ",");
            char temp[20];
            sprintf(temp, "%d", result);
            strcat(results, temp);
            first = 0;
        } else if (strncmp(ptr, "addEdge", 7) == 0) {
            ptr += 7;
            while (*ptr < '0' || *ptr > '9') ptr++;
            int edge[3];
            edge[0] = strtol(ptr, &ptr, 10);
            while (*ptr < '0' || *ptr > '9') ptr++;
            edge[1] = strtol(ptr, &ptr, 10);
            while (*ptr < '0' || *ptr > '9') ptr++;
            edge[2] = strtol(ptr, &ptr, 10);
            
            graphAddEdge(graph, edge);
            if (!first) strcat(results, ",");
            first = 0;
        } else {
            ptr++;
        }
    }
    
    printf("%s\n", results);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n³) for Floyd-Warshall on each addEdge, O(1) for shortestPath query

⚡ Linearithmic

Space Complexity

O(n²)

Distance matrix storing shortest paths between all pairs of nodes

✓ Linear Space

32.5K Views

High Frequency

~25 min Avg. Time

1.2K 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 (Floyd-Warshall Precomputation) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler