feat: implement Dijkstra's algorithm with tests for shortest path calculation

Author: monkey0722

algorithms/search/dijkstra/dijkstra.test.ts

@@ -0,0 +1,88 @@
+import {dijkstra, reconstructPath} from './dijkstra';
+
+describe('Dijkstra Algorithm', () => {
+  test('should find the shortest paths in a simple graph', () => {
+    const graph = [
+      [
+        {to: 1, weight: 1},
+        {to: 2, weight: 4},
+      ],
+      [
+        {to: 2, weight: 2},
+        {to: 3, weight: 5},
+      ],
+      [{to: 3, weight: 1}],
+      [],
+    ];
+    const {distances, predecessors} = dijkstra(graph, 0);
+    expect(distances).toEqual([0, 1, 3, 4]);
+    expect(predecessors).toEqual([-1, 0, 1, 2]);
+  });
+  test('should handle unreachable vertices', () => {
+    const graph = [[{to: 1, weight: 1}], [{to: 2, weight: 2}], [], []];
+    const {distances, predecessors} = dijkstra(graph, 0);
+    expect(distances).toEqual([0, 1, 3, Infinity]);
+    expect(predecessors).toEqual([-1, 0, 1, -1]);
+  });
+  test('should throw error for negative edge weights', () => {
+    const graph = [
+      [
+        {to: 1, weight: 1},
+        {to: 2, weight: -2},
+      ],
+      [],
+      [],
+    ];
+    expect(() => dijkstra(graph, 0)).toThrow(
+      "Dijkstra's algorithm does not work with negative edge weights",
+    );
+  });
+  test('should handle a graph with a single vertex', () => {
+    const graph = [[]];
+    const {distances, predecessors} = dijkstra(graph, 0);
+    expect(distances).toEqual([0]);
+    expect(predecessors).toEqual([-1]);
+  });
+  test('should handle a graph with multiple paths to the same vertex', () => {
+    const graph = [
+      [
+        {to: 1, weight: 1},
+        {to: 2, weight: 2},
+      ],
+      [{to: 3, weight: 4}],
+      [{to: 3, weight: 3}],
+      [],
+    ];
+    const {distances, predecessors} = dijkstra(graph, 0);
+    expect(distances[3]).toBe(5);
+    expect(predecessors[3]).toBe(1);
+  });
+});
+
+describe('reconstructPath', () => {
+  test('should reconstruct the correct path', () => {
+    const predecessors = [-1, 0, 1, 2];
+    const path = reconstructPath(0, 3, predecessors);
+    expect(path).toEqual([0, 1, 2, 3]);
+  });
+  test('should handle direct paths', () => {
+    const predecessors = [-1, 0, 0, 0];
+    const path = reconstructPath(0, 1, predecessors);
+    expect(path).toEqual([0, 1]);
+  });
+  test('should return null for unreachable vertices', () => {
+    const predecessors = [-1, 0, 1, -1];
+    const path = reconstructPath(0, 3, predecessors);
+    expect(path).toBeNull();
+  });
+  test('should handle path from vertex to itself', () => {
+    const predecessors = [-1, 0, 1, 2];
+    const path = reconstructPath(0, 0, predecessors);
+    expect(path).toEqual([0]);
+  });
+  test('should handle invalid target vertex', () => {
+    const predecessors = [-1, 0, 1, 2];
+    const path = reconstructPath(0, 4, predecessors);
+    expect(path).toBeNull();
+  });
+});

algorithms/search/dijkstra/dijkstra.ts

@@ -0,0 +1,119 @@
+/**
+ * Dijkstra's algorithm implementation for finding the shortest path in a weighted graph.
+ * The algorithm works with non-negative edge weights only.
+ */
+
+interface Edge {
+  to: number;
+  weight: number;
+}
+
+interface DijkstraResult {
+  distances: number[];
+  predecessors: number[];
+}
+
+/**
+ * Implements Dijkstra's algorithm to find shortest paths from a source vertex to all other vertices.
+ * This implementation uses an adjacency list representation of the graph.
+ *
+ * @param graph - Adjacency list representation of the graph where graph[i] is an array of edges from vertex i.
+ * @param source - The source vertex to start the search from.
+ * @returns An object containing the distances array and predecessors array.
+ * @throws If any edge has a negative weight.
+ */
+export function dijkstra(graph: Edge[][], source: number): DijkstraResult {
+  const n = graph.length;
+  const distances: number[] = Array(n).fill(Infinity);
+  distances[source] = 0;
+
+  const predecessors: number[] = Array(n).fill(-1);
+  const visited: boolean[] = Array(n).fill(false);
+
+  // Check for negative weights, which are not allowed in Dijkstra's algorithm
+  for (const edges of graph) {
+    for (const edge of edges) {
+      if (edge.weight < 0) {
+        throw new Error("Dijkstra's algorithm does not work with negative edge weights");
+      }
+    }
+  }
+
+  for (let i = 0; i < n; i++) {
+    const u = minDistanceVertex(distances, visited);
+    if (u === -1 || distances[u] === Infinity) {
+      break;
+    }
+    // Mark the picked vertex as visited
+    visited[u] = true;
+    // Update the distance values of the adjacent vertices
+    for (const edge of graph[u]) {
+      const v = edge.to;
+
+      // Update if:
+      // 1. The vertex v is not visited
+      // 2. There is an edge from u to v
+      // 3. The total weight of path from source to v through u is smaller than the current value of distances[v]
+      if (!visited[v] && distances[u] + edge.weight < distances[v]) {
+        distances[v] = distances[u] + edge.weight;
+        predecessors[v] = u;
+      }
+    }
+  }
+  return {distances, predecessors};
+}
+
+/**
+ * Helper function to find the vertex with the minimum distance value,
+ * from the set of vertices not yet included in the shortest path tree.
+ *
+ * @param distances - Array of distances from source to each vertex.
+ * @param visited - Array indicating which vertices have been visited.
+ * @returns The index of the vertex with the minimum distance, or -1 if no unvisited vertices remain.
+ */
+function minDistanceVertex(distances: number[], visited: boolean[]): number {
+  let min = Infinity;
+  let minIndex = -1;
+  for (let v = 0; v < distances.length; v++) {
+    if (!visited[v] && distances[v] <= min) {
+      min = distances[v];
+      minIndex = v;
+    }
+  }
+  return minIndex;
+}
+
+/**
+ * Reconstructs the shortest path from a source vertex to a target vertex.
+ *
+ * @param source - The source vertex.
+ * @param target - The target vertex.
+ * @param predecessors - Array of predecessor vertices obtained from Dijkstra's algorithm.
+ * @returns An array representing the path from source to target, or null if no path exists.
+ */
+export function reconstructPath(
+  source: number,
+  target: number,
+  predecessors: number[],
+): number[] | null {
+  if (
+    target < 0 ||
+    target >= predecessors.length ||
+    (predecessors[target] === -1 && source !== target)
+  ) {
+    return null;
+  }
+
+  const path: number[] = [];
+  let current = target;
+
+  while (current !== -1) {
+    path.unshift(current);
+    if (current === source) {
+      break;
+    }
+    current = predecessors[current];
+  }
+  // Check if the path starts with the source vertex
+  return path[0] === source ? path : null;
+}