Design Graph With Shortest Path Calculator

1class Graph {
2    constructor(n, edges) {
3        this.n = n;
4        this.adj = Array.from({ length: n }, () => []);
5        for (const [u, v, cost] of edges) {
6            this.adj[u].push([v, cost]);
7        }
8    }
9
10    addEdge(edge) {
11        const [u, v, cost] = edge;
12        this.adj[u].push([v, cost]);
13    }
14
15    shortestPath(node1, node2) {
16        const dist = new Array(this.n).fill(Infinity);
17        dist[node1] = 0;
18        const pq = new PriorityQueue((a, b) => a[0] < b[0]);
19        pq.enqueue([0, node1]);
20
21        while (!pq.isEmpty()) {
22            const [curDist, u] = pq.dequeue();
23            if (u === node2) return curDist;
24            if (curDist > dist[u]) continue;
25
26            for (const [v, cost] of this.adj[u]) {
27                if (dist[u] + cost < dist[v]) {
28                    dist[v] = dist[u] + cost;
29                    pq.enqueue([dist[v], v]);
30                }
31            }
32        }
33        return -1;
34    }
35}
36
37class PriorityQueue {
38    constructor(comparator) {
39        this.data = [];
40        this.comparator = comparator;
41    }
42
43    enqueue(value) {
44        this.data.push(value);
45        this.data.sort(this.comparator);
46    }
47
48    dequeue() {
49        return this.data.shift();
50    }
51
52    isEmpty() {
53        return this.data.length === 0;
54    }
55}
56
57// Demonstration
58const edges = [[0, 2, 5], [0, 1, 2], [1, 2, 1], [3, 0, 3]];
59const graph = new Graph(4, edges);
60console.log(graph.shortestPath(3, 2)); // Output: 6
61console.log(graph.shortestPath(0, 3)); // Output: -1
62graph.addEdge([1, 3, 4]);
63console.log(graph.shortestPath(0, 3)); // Output: 6
64

1#include <stdio.h>
2#include <stdlib.h>
3#include <limits.h>
4
5#define INF INT_MAX
6
7typedef struct {
8    int n;
9    int** dist;
10} Graph;
11
12Graph* createGraph(int n, int edges[][3], int edgesSize) {
13    Graph* graph = (Graph*)malloc(sizeof(Graph));
14    graph->n = n;
15    graph->dist = (int**)malloc(n * sizeof(int*));
16    for (int i = 0; i < n; i++) {
17        graph->dist[i] = (int*)malloc(n * sizeof(int));
18        for (int j = 0; j < n; j++)
19            graph->dist[i][j] = (i == j) ? 0 : INF;
20    }
21    for (int i = 0; i < edgesSize; i++) {
22        int u = edges[i][0];
23        int v = edges[i][1];
24        graph->dist[u][v] = edges[i][2];
25    }
26    for (int k = 0; k < n; k++) {
27        for (int i = 0; i < n; i++) {
28            for (int j = 0; j < n; j++) {
29                if (graph->dist[i][k] != INF && graph->dist[k][j] != INF)
30                    graph->dist[i][j] = (graph->dist[i][j] > graph->dist[i][k] + graph->dist[k][j]) ? graph->dist[i][k] + graph->dist[k][j] : graph->dist[i][j];
31            }
32        }
33    }
34    
35    return graph;
36}
37
38void addEdge(Graph* graph, int u, int v, int cost) {
39    graph->dist[u][v] = cost;
40    // Re-run Floyd-Warshall
41    for (int k = 0; k < graph->n; k++) {
42        for (int i = 0; i < graph->n; i++) {
43            for (int j = 0; j < graph->n; j++) {
44                if (graph->dist[i][k] != INF && graph->dist[k][j] != INF)
45                    graph->dist[i][j] = (graph->dist[i][j] > graph->dist[i][k] + graph->dist[k][j]) ? graph->dist[i][k] + graph->dist[k][j] : graph->dist[i][j];
46            }
47        }
48    }
49}
50
51int shortestPath(Graph* graph, int node1, int node2) {
52    if(graph->dist[node1][node2] == INF)
53        return -1;
54    return graph->dist[node1][node2];
55}
56
57int main() {
58    int edges[4][3] = {{0, 2, 5}, {0, 1, 2}, {1, 2, 1}, {3, 0, 3}};
59    Graph* graph = createGraph(4, edges, 4);
60    printf("%d\n", shortestPath(graph, 3, 2)); // Output: 6
61    printf("%d\n", shortestPath(graph, 0, 3)); // Output: -1
62    addEdge(graph, 1, 3, 4);
63    printf("%d\n", shortestPath(graph, 0, 3)); // Output: 6
64    
65    // Free the memory
66    for(int i = 0; i < graph->n; i++)
67        free(graph->dist[i]);
68    free(graph->dist);
69    free(graph);
70    return 0;
71}