Merge pull request #110 from JesusTheHun/fix/shortest-path-next-weight

fix: compute next weight from source to destination

Author: curran

src/algorithms/shortestPath/getPath.ts

@@ -3,6 +3,7 @@ import type { TraversingTracks } from './types.js';
 import type { NextWeightFnParams } from '../../types.js';
 
 import { Graph } from '../../Graph.js';
+import { invariant } from '../../invariant.js';
 
 /**
  * Computes edge weight as the sum of all the edges in the path.
@@ -23,34 +24,22 @@ export function getPath<Node, LinkProps>(
   tracks: TraversingTracks<NoInfer<Node>>,
   source: NoInfer<Node>,
   destination: NoInfer<Node>,
-  nextWeightFn: (params: NextWeightFnParams) => number = addWeightFunction,
+  nextWeightFn: (
+    params: NextWeightFnParams<Node, LinkProps>,
+  ) => number = addWeightFunction,
 ): {
   nodes: [Node, Node, ...Node[]];
   weight: number | undefined;
 } {
   const { p } = tracks;
-  const nodeList: Node[] & { weight?: EdgeWeight } = [];
+  const nodeList: Node[] = [];
 
-  let totalWeight: EdgeWeight | undefined = undefined;
   let node = destination;
 
-  let hop = 1;
   while (p.has(node)) {
     const currentNode = p.get(node)!;
-
     nodeList.push(node);
-    const edgeWeight = graph.getEdgeWeight(currentNode, node);
-    totalWeight = nextWeightFn({
-      edgeWeight,
-      currentPathWeight: totalWeight,
-      hop: hop,
-      graph: graph,
-      path: tracks,
-      previousNode: node,
-      currentNode: currentNode,
-    });
     node = currentNode;
-    hop++;
   }
 
   if (node !== source) {
@@ -60,6 +49,30 @@ export function getPath<Node, LinkProps>(
   nodeList.push(node);
   nodeList.reverse();
 
+  invariant(nodeList.length >= 2, 'The path should have a least two nodes');
+
+  let totalWeight: EdgeWeight | undefined = undefined;
+
+  // We start as index=1 to work on the first edge between node 0 and 1
+  for (let i = 1; i < nodeList.length; i++) {
+    const previousNode = nodeList[i - 1]!;
+    const currentNode = nodeList[i]!;
+
+    const edgeWeight = graph.getEdgeWeight(previousNode, currentNode);
+    const edgeProps = graph.getEdgeProperties(previousNode, currentNode)!;
+
+    totalWeight = nextWeightFn({
+      edgeWeight,
+      currentPathWeight: totalWeight,
+      hop: i,
+      graph,
+      path: nodeList as [Node, Node, ...Node[]],
+      previousNode,
+      currentNode,
+      props: edgeProps,
+    });
+  }
+
   return {
     nodes: nodeList as [Node, Node, ...Node[]],
     weight: totalWeight,

src/algorithms/shortestPath/shortestPath.spec.ts

@@ -79,8 +79,6 @@ describe("Dijkstra's Shortest Path Algorithm", function () {
       .addEdge('e', 'f')
       .addEdge('f', 'c');
 
-    const serializedGraph = serializeGraph(graph);
-
     expect(shortestPaths(graph, 'a', 'c')).toEqual([
       { nodes: ['a', 'b', 'c'], weight: 2 },
       { nodes: ['a', 'd', 'c'], weight: 2 },
@@ -115,9 +113,10 @@ describe('addWeightFunction', () => {
       currentPathWeight: undefined,
       hop: 1,
       graph: graph,
-      path: { d: new Map(), p: new Map(), q: new Set() },
+      path: ['a', 'b'] as const,
       previousNode: 'a',
       currentNode: 'b',
+      props: undefined,
     };
     expect(addWeightFunction(params)).toBe(5);
   });
@@ -129,9 +128,10 @@ describe('addWeightFunction', () => {
       currentPathWeight: 10,
       hop: 1,
       graph: graph,
-      path: { d: new Map(), p: new Map(), q: new Set() },
+      path: ['a', 'b'] as const,
       previousNode: 'a',
       currentNode: 'b',
+      props: undefined,
     };
     expect(addWeightFunction(params)).toBe(15);
   });
@@ -161,7 +161,7 @@ describe('shortestPath with custom weight functions', () => {
     const graph = new Graph().addEdge('a', 'b', 2).addEdge('b', 'c', 3);
     expect(shortestPath(graph, 'a', 'c', customWeightFn)).toEqual({
       nodes: ['a', 'b', 'c'],
-      weight: 7,
+      weight: 11,
     });
   });
 
@@ -179,44 +179,25 @@ describe('shortestPath with custom weight functions', () => {
     shortestPath(graph, 'a', 'c', customWeightFn);
 
     expect(customWeightFn).toHaveBeenCalledWith({
-      edgeWeight: 2,
+      edgeWeight: 1,
       currentPathWeight: undefined,
       hop: 1,
       graph: graph,
+      previousNode: 'a',
       currentNode: 'b',
-      previousNode: 'c',
-      path: {
-        d: new Map([
-          ['a', 0],
-          ['b', 1],
-          ['c', 3],
-        ]),
-        p: new Map([
-          ['b', 'a'],
-          ['c', 'b'],
-        ]),
-        q: new Set(),
-      },
+      path: ['a', 'b', 'c'],
+      props: undefined,
     });
+
     expect(customWeightFn).toHaveBeenCalledWith({
-      edgeWeight: 1,
-      currentPathWeight: 2,
+      edgeWeight: 2,
+      currentPathWeight: 1,
       hop: 2,
       graph: graph,
-      currentNode: 'a',
       previousNode: 'b',
-      path: {
-        d: new Map([
-          ['a', 0],
-          ['b', 1],
-          ['c', 3],
-        ]),
-        p: new Map([
-          ['b', 'a'],
-          ['c', 'b'],
-        ]),
-        q: new Set(),
-      },
+      currentNode: 'c',
+      path: ['a', 'b', 'c'],
+      props: undefined,
     });
   });
 

src/types.ts

@@ -1,4 +1,3 @@
-import { TraversingTracks } from './algorithms/shortestPath/types.js';
 import { Graph } from './Graph.js';
 
 export type EdgeWeight = number;
@@ -27,7 +26,8 @@ export type NextWeightFnParams<Node = unknown, LinkProps = unknown> = {
   currentPathWeight: EdgeWeight | undefined;
   hop: number;
   graph: Graph<Node, LinkProps>;
-  path: TraversingTracks<NoInfer<Node>>;
-  previousNode: NoInfer<Node>;
+  path: readonly [NoInfer<Node>, NoInfer<Node>, ...NoInfer<Node>[]];
+  previousNode: NoInfer<Node> | undefined;
   currentNode: NoInfer<Node>;
+  props: LinkProps;
 };