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

Understanding the Visualization

Initial Graph

Start with nodes and initial edges

Query Path

Use Dijkstra's algorithm to find shortest path

Add New Edge

Dynamically add edge to adjacency list

Updated Path

New shortest path discovered after graph update

Key Takeaway

🎯 Key Insight: Dynamic graphs benefit from adjacency lists for O(1) edge additions combined with on-demand shortest path algorithms like Dijkstra's for efficient queries!

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

Approach	Time	Space	Notes
✓ Brute Force (Floyd-Warshall Precomputation)	O(n³)	O(n²)	Precompute all shortest paths and update entire matrix on edge addition
Dijkstra's Algorithm (Optimal)	O((V + E) log V)	O(V + E)	Use adjacency list with on-demand Dijkstra's algorithm for shortest path queries

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>

#define INF (INT_MAX / 2)

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

Graph* graphCreate(int n, int** edges, int edgesSize, int* edgesColSize) {
    Graph* g = malloc(sizeof(Graph));
    g->n = n;
    g->dist = malloc(n * sizeof(int*));
    
    // Initialize distance matrix
    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;
        }
    }
    
    // Add initial edges
    for (int i = 0; i < edgesSize; i++) {
        g->dist[edges[i][0]][edges[i][1]] = edges[i][2];
    }
    
    // Floyd-Warshall algorithm
    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, int edgeSize) {
    g->dist[edge[0]][edge[1]] = edge[2];
    
    // Rerun Floyd-Warshall
    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];
}

void graphFree(Graph* g) {
    for (int i = 0; i < g->n; i++) {
        free(g->dist[i]);
    }
    free(g->dist);
    free(g);
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

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

⚠ Quadratic Growth

Space Complexity

O(n²)

Distance matrix storing shortest paths between all pairs of nodes

⚠ Quadratic 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