Merge pull request #62 from monkey0722/feature/20250308

feat: Dijkstra's Algorithm and Topological Sort

Author: monkey0722

README.md

@@ -1 +1,3 @@
 # Computer Science in TypeScript
+
+The friendly graveyard where optimistic developers implement algorithms they secretly admire but rarely use!

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;
+}

algorithms/search/topological-sort/topological-sort.test.ts

@@ -0,0 +1,56 @@
+import {topologicalSort} from './topological-sort';
+
+describe('topologicalSort', () => {
+  test('should return a valid topological ordering for a simple DAG', () => {
+    const graph = [[1], [2], [3], []];
+    const result = topologicalSort(graph);
+    expect(result).toEqual([0, 1, 2, 3]);
+  });
+  test('should return a valid topological ordering for a more complex DAG', () => {
+    const graph = [[1, 2], [3], [3], []];
+    const result = topologicalSort(graph);
+    expect(result).not.toBeNull();
+    if (result) {
+      expect(result.indexOf(0)).toBeLessThan(result.indexOf(1));
+      expect(result.indexOf(0)).toBeLessThan(result.indexOf(2));
+      expect(result.indexOf(1)).toBeLessThan(result.indexOf(3));
+      expect(result.indexOf(2)).toBeLessThan(result.indexOf(3));
+    }
+  });
+  test('should return null for a graph with a cycle', () => {
+    const graph = [[1], [2], [0]];
+    const result = topologicalSort(graph);
+    expect(result).toBeNull();
+  });
+  test('should return a valid ordering for a disconnected DAG', () => {
+    const graph = [[1], [], [3], []];
+    const result = topologicalSort(graph);
+    expect(result).not.toBeNull();
+    if (result) {
+      expect(result.indexOf(0)).toBeLessThan(result.indexOf(1));
+      expect(result.indexOf(2)).toBeLessThan(result.indexOf(3));
+    }
+  });
+
+  test('should handle a graph with a single vertex', () => {
+    const graph = [[]];
+    const result = topologicalSort(graph);
+    expect(result).toEqual([0]);
+  });
+
+  test('should handle an empty graph', () => {
+    const graph: number[][] = [];
+    const result = topologicalSort(graph);
+    expect(result).toEqual([]);
+  });
+  test('should handle a graph with self-loops', () => {
+    const graph = [[1], [1, 2], []];
+    const result = topologicalSort(graph);
+    expect(result).toBeNull();
+  });
+  test('should handle a graph with multiple cycles', () => {
+    const graph = [[1], [2], [0], [4], [3]];
+    const result = topologicalSort(graph);
+    expect(result).toBeNull();
+  });
+});

algorithms/search/topological-sort/topological-sort.ts

@@ -0,0 +1,62 @@
+/**
+ * Implementation of Topological Sort algorithm.
+ *
+ * Topological Sort is an algorithm used to linearly order the vertices of a directed graph
+ * such that for every directed edge (u, v), vertex u comes before vertex v in the ordering.
+ *
+ * This algorithm only works on Directed Acyclic Graphs (DAGs).
+ * If the graph contains a cycle, no valid topological sort exists.
+ */
+
+const VertexState = {
+  UNVISITED: 0,
+  VISITING: 1,
+  VISITED: 2,
+} as const;
+
+type VertexState = (typeof VertexState)[keyof typeof VertexState];
+
+/**
+ * Performs a topological sort on a directed graph represented as an adjacency list.
+ *
+ * @param graph - Adjacency list representation of the graph where graph[i] contains
+ *                the vertices that vertex i has edges to.
+ * @returns An array of vertices in topological order, or null if the graph contains a cycle.
+ */
+export function topologicalSort(graph: number[][]): number[] | null {
+  const n = graph.length;
+  const state: VertexState[] = Array(n).fill(VertexState.UNVISITED);
+  const result: number[] = [];
+
+  const dfs = (vertex: number): boolean => {
+    if (state[vertex] === VertexState.VISITING) {
+      return false;
+    }
+
+    // If vertex is already visited, no need to process it again
+    if (state[vertex] === VertexState.VISITED) {
+      return true;
+    }
+
+    state[vertex] = VertexState.VISITING;
+
+    for (const neighbor of graph[vertex]) {
+      if (!dfs(neighbor)) {
+        return false;
+      }
+    }
+    state[vertex] = VertexState.VISITED;
+    result.unshift(vertex);
+    return true;
+  };
+
+  // Try to visit each unvisited vertex
+  for (let i = 0; i < n; i++) {
+    if (state[i] === VertexState.UNVISITED) {
+      if (!dfs(i)) {
+        return null;
+      }
+    }
+  }
+  return result;
+}