1.2 Practice. Add Dijkstra's shortest path

Author: another-guy

__tests__/1-2-dijkstra-shortest-path.spec.ts

@@ -0,0 +1,24 @@
+import { dijkstraShortestPath } from '../src/practice/1-2-dijkstra-shortest-path';
+
+const graph = {
+  nodes: ['a', 'b', 'c', 'd', 'e', 'f'],
+  edges: [
+    { source: 'a', destination: 'b', distance: 7 },
+    { source: 'a', destination: 'c', distance: 9 },
+    { source: 'a', destination: 'f', distance: 14 },
+    { source: 'b', destination: 'c', distance: 10 },
+    { source: 'b', destination: 'd', distance: 15 },
+    { source: 'c', destination: 'f', distance: 2 },
+    { source: 'c', destination: 'd', distance: 11 },
+    { source: 'd', destination: 'e', distance: 6 },
+    { source: 'e', destination: 'f', distance: 9 },
+  ],
+};
+
+describe(dijkstraShortestPath.name, () => {
+  it(`Should pass end-to-end test`, () => {
+    const result = dijkstraShortestPath(graph, 'a', 'e');
+    expect(result.distance).toBe(20);
+    expect(result.nodeList).toEqual(['a', 'c', 'f', 'e']);
+  });
+});

src/practice/0-undirected-graph.ts

@@ -0,0 +1,10 @@
+export interface IEdge {
+  source: string;
+  destination: string;
+  distance: number;
+}
+
+export interface IGraph {
+  nodes: string[];
+  edges: IEdge[];
+}

src/practice/1-2-dijkstra-shortest-path.ts

@@ -0,0 +1,71 @@
+import { IGraph } from './0-undirected-graph';
+ 
+export interface IPath {
+  nodeList: string[];
+  distance: number;
+}
+ 
+export function dijkstraShortestPath(
+  graph: IGraph,
+  sourceNode: string,
+  destinationNode: string,
+): IPath {
+  const edges = new Set(graph.edges);
+  const distanceTo = graph.nodes
+    .reduce(
+      (result, node) => (
+        result[node] = {
+          from: null,
+          distance: node === sourceNode ? 0 : Number.MAX_SAFE_INTEGER,
+        },
+        result
+      ),
+      {} as { [ dest: string ]: { from: string | null, distance: number } }
+    );
+ 
+  const unvisited = new Set(graph.nodes);
+ 
+  let currentNode: string | undefined = sourceNode;
+  do {
+    unvisited.delete(currentNode);
+ 
+    for (let edge of edges)
+      if (edge.source === currentNode || edge.destination === currentNode) {
+        edges.delete(edge);
+ 
+        const neighbor = edge.source === currentNode ? edge.destination : edge.source;
+        const alternativeDistance = distanceTo[currentNode].distance + edge.distance;
+ 
+        if (alternativeDistance < distanceTo[neighbor].distance) {
+          distanceTo[neighbor] = { from: currentNode, distance: alternativeDistance };
+        }
+      }
+ 
+    // current = unvisited node with shortest `distance` path to it
+    let closestUnvisitedEntry = (Object
+      .entries(distanceTo)
+      .sort((entry1, entry2) => entry1["1"].distance - entry2["1"].distance)
+      .find(entry => unvisited.has(entry["0"])));
+    currentNode = closestUnvisitedEntry && closestUnvisitedEntry["0"];
+ 
+  } while (currentNode);
+ 
+  return {
+    distance: distanceTo[destinationNode].distance,
+    nodeList: unwindPath(distanceTo, destinationNode),
+  };
+}
+ 
+export function unwindPath(
+  distanceTo: { [dest: string]: { from: string | null, distance: number } },
+  destinationNode: string,
+) {
+  const path: string[] = [ destinationNode ];
+  let currentNode: string | null = destinationNode;
+  do {
+    const entry: { from: string | null, distance: number } = distanceTo[currentNode];
+    currentNode = entry.from;
+    if (currentNode) path.unshift(currentNode);
+  } while (currentNode);
+  return path;
+}