feat: add johnson algorithm for all pairs shortest paths (#145)

* feat: add johnson algorithm for all pairs shortest paths

* fix initializing edges. add test case for empty graph and disjoint
graph.

* more detail to test description

* Remove accidentally committed files

graph/johnson.ts

@@ -0,0 +1,52 @@
+import { bellmanFord } from './bellman_ford'
+import { dijkstra } from './dijkstra'
+
+/**
+ * @function johnson
+ * @description Compute the shortest path for all pairs of nodes. The input graph is in adjacency list form. It is a multidimensional array of edges. graph[i] holds the edges for the i'th node. Each edge is a 2-tuple where the 0'th item is the destination node, and the 1'th item is the edge weight. Returned undefined if the graph has negative weighted cycles.
+ * @Complexity_Analysis
+ * Time complexity: O(VElog(V))
+ * Space Complexity: O(V^2) to hold the result
+ * @param {[number, number][][]} graph - The graph in adjacency list form
+ * @return {number[][]} - A matrix holding the shortest path for each pair of nodes. matrix[i][j] holds the distance of the shortest path (i -> j).
+ * @see https://en.wikipedia.org/wiki/Johnson%27s_algorithm
+ */
+export const johnson = (graph: [number, number][][]): number[][] | undefined => {
+ let N = graph.length;
+
+ // Add a new node and 0 weighted edges from the new node to all existing nodes.
+ let newNodeGraph = structuredClone(graph);
+ let newNode: [number, number][] = [];
+ for (let i = 0; i < N; ++i) {
+ newNode.push([i, 0]);
+ }
+ newNodeGraph.push(newNode);
+
+ // Compute distances from the new node to existing nodes using the Bellman-Ford algorithm.
+ let adjustedGraph = bellmanFord(newNodeGraph, N);
+ if (adjustedGraph === undefined) {
+ // Found a negative weight cycle.
+ return undefined;
+ }
+
+ for (let i = 0; i < N; ++i) {
+ for (let edge of graph[i]) {
+ // Adjust edge weights using the Bellman Ford output weights. This ensure that:
+ // 1. Each weight is non-negative. This is required for the Dijkstra algorithm.
+ // 2. The shortest path from node i to node j consists of the same nodes with or without adjustment.
+ edge[1] += adjustedGraph[i] - adjustedGraph[edge[0]];
+ }
+ }
+
+ let shortestPaths: number[][] = [];
+ for (let i = 0; i < N; ++i) {
+ // Compute Dijkstra weights for each node and re-adjust weights to their original values.
+ let dijkstraShorestPaths = dijkstra(graph, i);
+ for (let j = 0; j < N; ++j) {
+ dijkstraShorestPaths[j] += adjustedGraph[j] - adjustedGraph[i];
+ }
+ shortestPaths.push(dijkstraShorestPaths);
+ }
+ return shortestPaths;
+}
+

graph/test/johnson.test.ts

@@ -0,0 +1,107 @@
+import { johnson } from "../johnson";
+
+describe("johnson", () => {
+
+ const init_graph = (N: number): [number, number][][] => {
+ let graph = Array(N);
+ for (let i = 0; i < N; ++i) {
+ graph[i] = [];
+ }
+ return graph;
+ }
+
+ const add_edge = (graph: [number, number][][], a: number, b: number, weight: number) => {
+ graph[a].push([b, weight]);
+ graph[b].push([a, weight]);
+ }
+
+ it("should return the correct value", () => {
+ let graph = init_graph(9);
+ add_edge(graph, 0, 1, 4);
+ add_edge(graph, 0, 7, 8);
+ add_edge(graph, 1, 2, 8);
+ add_edge(graph, 1, 7, 11);
+ add_edge(graph, 2, 3, 7);
+ add_edge(graph, 2, 5, 4);
+ add_edge(graph, 2, 8, 2);
+ add_edge(graph, 3, 4, 9);
+ add_edge(graph, 3, 5, 14);
+ add_edge(graph, 4, 5, 10);
+ add_edge(graph, 5, 6, 2);
+ add_edge(graph, 6, 7, 1);
+ add_edge(graph, 6, 8, 6);
+ add_edge(graph, 7, 8, 7);
+
+ let expected = [
+ [0, 4, 12, 19, 21, 11, 9, 8, 14],
+ [4, 0, 8, 15, 22, 12, 12, 11, 10],
+ [12, 8, 0, 7, 14, 4, 6, 7, 2],
+ [19, 15, 7, 0, 9, 11, 13, 14, 9],
+ [21, 22, 14, 9, 0, 10, 12, 13, 16],
+ [11, 12, 4, 11, 10, 0, 2, 3, 6],
+ [9, 12, 6, 13, 12, 2, 0, 1, 6],
+ [8, 11, 7, 14, 13, 3, 1, 0, 7],
+ [14, 10, 2, 9, 16, 6, 6, 7, 0]
+ ]
+ expect(johnson(graph)).toStrictEqual(expected);
+ });
+
+ it("should return the correct value for graph with negative weights", () => {
+ let graph = init_graph(4);
+ graph[0].push([1, -5]);
+ graph[0].push([2, 2]);
+ graph[0].push([3, 3]);
+ graph[1].push([2, 4]);
+ graph[2].push([3, 1]);
+
+ let expected = [
+ [ 0, -5, -1, 0 ],
+ [ Infinity, 0, 4, 5 ],
+ [ Infinity, Infinity, 0, 1 ],
+ [ Infinity, Infinity, Infinity, 0 ]
+ ]
+ expect(johnson(graph)).toStrictEqual(expected);
+ });
+
+ it("should return the undefined for two node graph with negative-weight cycle", () => {
+ let graph = init_graph(2);
+ add_edge(graph, 0, 1, -1);
+ expect(johnson(graph)).toStrictEqual(undefined);
+ });
+
+ it("should return the undefined for three node graph with negative-weight cycle", () => {
+ let graph = init_graph(3);
+ graph[0].push([1, -1]);
+ graph[0].push([2, 7]);
+ graph[1].push([2, -5]);
+ graph[2].push([0, 4]);
+ expect(johnson(graph)).toStrictEqual(undefined);
+ });
+
+ it("should return the correct value for zero element graph", () => {
+ expect(johnson([])).toStrictEqual([]);
+ });
+
+ it("should return the correct value for single element graph", () => {
+ expect(johnson([[]])).toStrictEqual([[0]]);
+ });
+
+ it("should return the correct value for a linear graph", () => {
+ let linear_graph = init_graph(4);
+ add_edge(linear_graph, 0, 1, 1);
+ add_edge(linear_graph, 1, 2, 2);
+ add_edge(linear_graph, 2, 3, 3);
+
+ let expected = [[0, 1, 3, 6 ], [1, 0, 2, 5], [3, 2, 0, 3], [6, 5, 3, 0]];
+ expect(johnson(linear_graph)).toStrictEqual(expected);
+ });
+
+ it("should return the correct value for a linear graph with unreachable node", () => {
+ let linear_graph = init_graph(3);
+ add_edge(linear_graph, 0, 1, 1);
+
+ let expected = [[0, 1, Infinity], [1, 0, Infinity], [Infinity, Infinity, 0]];
+ expect(johnson(linear_graph)).toStrictEqual(expected);
+ });
+})
+