fix: shortestPath with wrong result;

Author: shiwu

packages/graph/src/dijkstra.ts

@@ -1,10 +1,11 @@
-import { GraphData, NodeConfig, EdgeConfig } from "./types";
-import { getOutEdgesNodeId, getEdgesByNodeId } from "./util";
+import { isArray } from '@antv/util';
+import { GraphData, NodeConfig, EdgeConfig } from './types';
+import { getOutEdgesNodeId, getEdgesByNodeId } from './util';
 
 const minVertex = (
   D: { [key: string]: number },
   nodes: NodeConfig[],
-  marks: { [key: string]: boolean }
+  marks: { [key: string]: boolean },
 ): NodeConfig => {
   // 找出最小的点
   let minDis = Infinity;
@@ -23,7 +24,7 @@ const dijkstra = (
   graphData: GraphData,
   source: string,
   directed?: boolean,
-  weightPropertyName?: string
+  weightPropertyName?: string,
 ) => {
   const { nodes = [], edges = [] } = graphData;
   const nodeIds = [];
@@ -50,14 +51,11 @@ const dijkstra = (
     if (directed) relatedEdges = getOutEdgesNodeId(minNodeId, edges);
     else relatedEdges = getEdgesByNodeId(minNodeId, edges);
 
-    relatedEdges.forEach((edge) => {
+    relatedEdges.forEach(edge => {
       const edgeTarget = edge.target;
       const edgeSource = edge.source;
       const w = edgeTarget === minNodeId ? edgeSource : edgeTarget;
-      const weight =
-        weightPropertyName && edge[weightPropertyName]
-          ? edge[weightPropertyName]
-          : 1;
+      const weight = weightPropertyName && edge[weightPropertyName] ? edge[weightPropertyName] : 1;
       if (D[w] > D[minNode.id] + weight) {
         D[w] = D[minNode.id] + weight;
         prevs[w] = [minNode.id];
@@ -87,6 +85,7 @@ const dijkstra = (
 export default dijkstra;
 
 function findAllPaths(source, target, prevs, foundPaths) {
+  debugger;
   if (source === target) {
     return [source];
   }
@@ -98,7 +97,8 @@ function findAllPaths(source, target, prevs, foundPaths) {
     const prevPaths = findAllPaths(source, prev, prevs, foundPaths);
     if (!prevPaths) return;
     for (let prePath of prevPaths) {
-      paths.push([...prePath, target]);
+      if (isArray(prePath)) paths.push([...prePath, target]);
+      else paths.push([prePath, target]);
     }
   }
   foundPaths[target] = paths;

packages/graph/tests/unit/find-path-spec.ts

@@ -1,128 +1,122 @@
-import { findAllPath, findShortestPath } from "../../src";
+import { findAllPath, findShortestPath } from '../../src';
 
 const data = {
   nodes: [
     {
-      id: "A",
-      label: "A",
+      id: 'A',
+      label: 'A',
     },
     {
-      id: "B",
-      label: "B",
+      id: 'B',
+      label: 'B',
     },
     {
-      id: "C",
-      label: "C",
+      id: 'C',
+      label: 'C',
     },
     {
-      id: "D",
-      label: "D",
+      id: 'D',
+      label: 'D',
     },
     {
-      id: "E",
-      label: "E",
+      id: 'E',
+      label: 'E',
     },
     {
-      id: "F",
-      label: "F",
+      id: 'F',
+      label: 'F',
     },
     {
-      id: "G",
-      label: "G",
+      id: 'G',
+      label: 'G',
     },
     {
-      id: "H",
-      label: "H",
+      id: 'H',
+      label: 'H',
     },
   ],
   edges: [
     {
-      source: "A",
-      target: "B",
+      source: 'A',
+      target: 'B',
     },
     {
-      source: "B",
-      target: "C",
+      source: 'B',
+      target: 'C',
     },
     {
-      source: "C",
-      target: "G",
+      source: 'C',
+      target: 'G',
     },
     {
-      source: "A",
-      target: "D",
+      source: 'A',
+      target: 'D',
     },
     {
-      source: "A",
-      target: "E",
+      source: 'A',
+      target: 'E',
     },
     {
-      source: "E",
-      target: "F",
+      source: 'E',
+      target: 'F',
     },
     {
-      source: "F",
-      target: "D",
+      source: 'F',
+      target: 'D',
     },
     {
-      source: "D",
-      target: "E",
+      source: 'D',
+      target: 'E',
     },
   ],
 };
 
-describe("Shortest Path from source to target on graph", () => {
-  it("find the shortest path", () => {
-    const { length, path } = findShortestPath(data, "A", "C");
+describe('Shortest Path from source to target on graph', () => {
+  it('find the shortest path', () => {
+    const { length, path } = findShortestPath(data, 'A', 'C');
     expect(length).toBe(2);
-    expect(path).toStrictEqual(["A", "B", "C"]);
+    expect(path).toStrictEqual(['A', 'B', 'C']);
   });
 
-  it("find all shortest paths", () => {
-    const { length, allPath } = findShortestPath(data, "A", "F");
+  it('find all shortest paths', () => {
+    const { length, allPath } = findShortestPath(data, 'A', 'F');
     expect(length).toBe(2);
-    expect(allPath[0]).toStrictEqual(["A", "E", "F"]);
-    expect(allPath[1]).toStrictEqual(["A", "D", "F"]);
+    expect(allPath[0]).toStrictEqual(['A', 'E', 'F']);
+    expect(allPath[1]).toStrictEqual(['A', 'D', 'F']);
 
     const {
       length: directedLenght,
       path: directedPath,
       allPath: directedAllPath,
-    } = findShortestPath(data, "A", "F", true);
+    } = findShortestPath(data, 'A', 'F', true);
     expect(directedLenght).toBe(2);
-    expect(directedAllPath[0]).toStrictEqual(["A", "E", "F"]);
-    expect(directedPath).toStrictEqual(["A", "E", "F"]);
+    expect(directedAllPath[0]).toStrictEqual(['A', 'E', 'F']);
+    expect(directedPath).toStrictEqual(['A', 'E', 'F']);
   });
 
-  it("find all paths", () => {
-    const allPaths = findAllPath(data, "A", "E");
+  it('find all paths', () => {
+    const allPaths = findAllPath(data, 'A', 'E');
     expect(allPaths.length).toBe(3);
-    expect(allPaths[0]).toStrictEqual(["A", "D", "F", "E"]);
-    expect(allPaths[1]).toStrictEqual(["A", "D", "E"]);
-    expect(allPaths[2]).toStrictEqual(["A", "E"]);
+    expect(allPaths[0]).toStrictEqual(['A', 'D', 'F', 'E']);
+    expect(allPaths[1]).toStrictEqual(['A', 'D', 'E']);
+    expect(allPaths[2]).toStrictEqual(['A', 'E']);
   });
 
-  it("find all paths in directed graph", () => {
-    const allPaths = findAllPath(data, "A", "E", true);
+  it('find all paths in directed graph', () => {
+    const allPaths = findAllPath(data, 'A', 'E', true);
     expect(allPaths.length).toStrictEqual(2);
-    expect(allPaths[0]).toStrictEqual(["A", "D", "E"]);
-    expect(allPaths[1]).toStrictEqual(["A", "E"]);
+    expect(allPaths[0]).toStrictEqual(['A', 'D', 'E']);
+    expect(allPaths[1]).toStrictEqual(['A', 'E']);
   });
 
-  it("find all shortest paths in weighted graph", () => {
+  it('find all shortest paths in weighted graph', () => {
     data.edges.forEach((edge, i) => {
       edge.weight = ((i % 2) + 1) * 2;
-      if (edge.source === "F" && edge.target === "D") edge.weight = 10;
+      if (edge.source === 'F' && edge.target === 'D') edge.weight = 10;
     });
-    const { length, path, allPath } = findShortestPath(
-      data,
-      "A",
-      "F",
-      false,
-      "weight"
-    );
+    const { length, path, allPath } = findShortestPath(data, 'A', 'F', false, 'weight');
     expect(length).toBe(6);
-    expect(allPath[0]).toStrictEqual(["A", "E", "F"]);
-    expect(path).toStrictEqual(["A", "E", "F"]);
+    expect(allPath[0]).toStrictEqual(['A', 'E', 'F']);
+    expect(path).toStrictEqual(['A', 'E', 'F']);
   });
 });