@graphty/algorithms 1.0.1 → 1.2.0

package/src/algorithms/shortest-path/floyd-warshall.ts

@@ -0,0 +1,170 @@
+import {Graph} from "../../core/graph.js";
+import type {NodeId} from "../../types/index.js";
+
+export interface FloydWarshallResult {
+    distances: Map<NodeId, Map<NodeId, number>>;
+    predecessors: Map<NodeId, Map<NodeId, NodeId | null>>;
+    hasNegativeCycle: boolean;
+}
+
+export function floydWarshall(graph: Graph): FloydWarshallResult {
+    const nodes = Array.from(graph.nodes()).map((n) => n.id);
+    const distances = new Map<NodeId, Map<NodeId, number>>();
+    const predecessors = new Map<NodeId, Map<NodeId, NodeId | null>>();
+
+    for (const node of nodes) {
+        distances.set(node, new Map());
+        predecessors.set(node, new Map());
+
+        const nodeDistances = distances.get(node);
+        const nodePredecessors = predecessors.get(node);
+
+        if (!nodeDistances || !nodePredecessors) {
+            continue;
+        }
+
+        for (const other of nodes) {
+            if (node === other) {
+                nodeDistances.set(other, 0);
+                nodePredecessors.set(other, null);
+            } else {
+                nodeDistances.set(other, Infinity);
+                nodePredecessors.set(other, null);
+            }
+        }
+    }
+
+    for (const edge of Array.from(graph.edges())) {
+        const weight = edge.weight ?? 1;
+        const sourceDistances = distances.get(edge.source);
+        const sourcePredecessors = predecessors.get(edge.source);
+
+        if (sourceDistances && sourcePredecessors) {
+            sourceDistances.set(edge.target, weight);
+            sourcePredecessors.set(edge.target, edge.source);
+        }
+
+        if (!graph.isDirected) {
+            const targetDistances = distances.get(edge.target);
+            const targetPredecessors = predecessors.get(edge.target);
+
+            if (targetDistances && targetPredecessors) {
+                targetDistances.set(edge.source, weight);
+                targetPredecessors.set(edge.source, edge.target);
+            }
+        }
+    }
+
+    for (const k of nodes) {
+        for (const i of nodes) {
+            for (const j of nodes) {
+                const distancesI = distances.get(i);
+                const distancesK = distances.get(k);
+                const predecessorsI = predecessors.get(i);
+                const predecessorsK = predecessors.get(k);
+
+                if (!distancesI || !distancesK || !predecessorsI || !predecessorsK) {
+                    continue;
+                }
+
+                const distIK = distancesI.get(k);
+                const distKJ = distancesK.get(j);
+                const distIJ = distancesI.get(j);
+
+                if (distIK === undefined || distKJ === undefined || distIJ === undefined) {
+                    continue;
+                }
+
+                if (distIK + distKJ < distIJ) {
+                    distancesI.set(j, distIK + distKJ);
+                    const predKJ = predecessorsK.get(j);
+                    predecessorsI.set(j, predKJ ?? null);
+                }
+            }
+        }
+    }
+
+    let hasNegativeCycle = false;
+    for (const node of nodes) {
+        const nodeDistances = distances.get(node);
+        if (!nodeDistances) {
+            continue;
+        }
+
+        const selfDistance = nodeDistances.get(node);
+        if (selfDistance !== undefined && selfDistance < 0) {
+            hasNegativeCycle = true;
+            break;
+        }
+    }
+
+    return {
+        distances,
+        predecessors,
+        hasNegativeCycle,
+    };
+}
+
+export function floydWarshallPath(
+    graph: Graph,
+    source: NodeId,
+    target: NodeId,
+): {path: NodeId[], distance: number} | null {
+    const result = floydWarshall(graph);
+
+    if (!graph.hasNode(source) || !graph.hasNode(target)) {
+        return null;
+    }
+
+    const sourceDistances = result.distances.get(source);
+    if (!sourceDistances) {
+        return null;
+    }
+
+    const distance = sourceDistances.get(target);
+    if (distance === undefined || distance === Infinity) {
+        return null;
+    }
+
+    const path: NodeId[] = [];
+    let current: NodeId | null = target;
+
+    while (current !== null && current !== source) {
+        path.unshift(current);
+
+        const sourcePredecessors = result.predecessors.get(source);
+        if (!sourcePredecessors) {
+            return null;
+        }
+
+        current = sourcePredecessors.get(current) ?? null;
+
+        if (path.length > graph.nodeCount) {
+            return null;
+        }
+    }
+
+    if (current === source) {
+        path.unshift(source);
+        return {path, distance};
+    }
+
+    return null;
+}
+
+export function transitiveClosure(graph: Graph): Map<NodeId, Set<NodeId>> {
+    const result = floydWarshall(graph);
+    const closure = new Map<NodeId, Set<NodeId>>();
+
+    for (const [source, distances] of Array.from(result.distances)) {
+        const reachable = new Set<NodeId>();
+        for (const [target, distance] of Array.from(distances)) {
+            if (distance < Infinity) {
+                reachable.add(target);
+            }
+        }
+        closure.set(source, reachable);
+    }
+
+    return closure;
+}

package/src/algorithms/shortest-path/index.ts

@@ -5,3 +5,5 @@
 export type {BellmanFordOptions, BellmanFordResult} from "./bellman-ford.js";
 export {bellmanFord, bellmanFordPath, hasNegativeCycle} from "./bellman-ford.js";
 export {allPairsShortestPath, dijkstra, dijkstraPath, singleSourceShortestPath} from "./dijkstra.js";
+export type {FloydWarshallResult} from "./floyd-warshall.js";
+export {floydWarshall, floydWarshallPath, transitiveClosure} from "./floyd-warshall.js";

package/src/algorithms/traversal/bfs.ts

@@ -185,7 +185,7 @@ export function isBipartite(graph: Graph): boolean {
     const visited = new Set<NodeId>();
 
     // Check each connected component
-    for (const node of graph.nodes()) {
+    for (const node of Array.from(graph.nodes())) {
         if (!visited.has(node.id)) {
             const queue: NodeId[] = [node.id];
             color.set(node.id, 0);
@@ -202,7 +202,7 @@ export function isBipartite(graph: Graph): boolean {
                     continue;
                 }
 
-                for (const neighbor of graph.neighbors(current)) {
+                for (const neighbor of Array.from(graph.neighbors(current))) {
                     if (!visited.has(neighbor)) {
                         // Color with opposite color
                         color.set(neighbor, currentColor === 0 ? 1 : 0);

package/src/algorithms/traversal/dfs.ts

@@ -127,7 +127,7 @@ function dfsRecursive(
     }
 
     // Recursively visit neighbors
-    for (const neighbor of graph.neighbors(node)) {
+    for (const neighbor of Array.from(graph.neighbors(node))) {
         if (!visited.has(neighbor)) {
             dfsRecursive(graph, neighbor, visited, order, tree, options, depth + 1, node);
         }
@@ -150,7 +150,7 @@ export function hasCycleDFS(graph: Graph): boolean {
     const visited = new Set<NodeId>();
 
     // Check each unvisited node for cycles
-    for (const node of graph.nodes()) {
+    for (const node of Array.from(graph.nodes())) {
         if (!visited.has(node.id)) {
             if (graph.isDirected) {
                 const recursionStack = new Set<NodeId>();
@@ -181,7 +181,7 @@ function hasCycleUtilDirected(
     recursionStack.add(node);
 
     // Check all neighbors
-    for (const neighbor of graph.neighbors(node)) {
+    for (const neighbor of Array.from(graph.neighbors(node))) {
         if (!visited.has(neighbor)) {
             if (hasCycleUtilDirected(graph, neighbor, visited, recursionStack)) {
                 return true;
@@ -208,7 +208,7 @@ function hasCycleUtilUndirected(
     visited.add(node);
 
     // Check all neighbors
-    for (const neighbor of graph.neighbors(node)) {
+    for (const neighbor of Array.from(graph.neighbors(node))) {
         if (!visited.has(neighbor)) {
             if (hasCycleUtilUndirected(graph, neighbor, visited, node)) {
                 return true;
@@ -239,7 +239,7 @@ export function topologicalSort(graph: Graph): NodeId[] | null {
     const stack: NodeId[] = [];
 
     // Perform DFS from each unvisited node
-    for (const node of graph.nodes()) {
+    for (const node of Array.from(graph.nodes())) {
         if (!visited.has(node.id)) {
             topologicalSortUtil(graph, node.id, visited, stack);
         }
@@ -261,7 +261,7 @@ function topologicalSortUtil(
     visited.add(node);
 
     // Visit all neighbors first
-    for (const neighbor of graph.neighbors(node)) {
+    for (const neighbor of Array.from(graph.neighbors(node))) {
         if (!visited.has(neighbor)) {
             topologicalSortUtil(graph, neighbor, visited, stack);
         }
@@ -283,7 +283,7 @@ export function findStronglyConnectedComponents(graph: Graph): NodeId[][] {
     const finishOrder: NodeId[] = [];
 
     // Step 1: Get nodes in order of finishing times
-    for (const node of graph.nodes()) {
+    for (const node of Array.from(graph.nodes())) {
         if (!visited.has(node.id)) {
             dfsFinishOrder(graph, node.id, visited, finishOrder);
         }
@@ -319,7 +319,7 @@ function dfsFinishOrder(
 ): void {
     visited.add(node);
 
-    for (const neighbor of graph.neighbors(node)) {
+    for (const neighbor of Array.from(graph.neighbors(node))) {
         if (!visited.has(neighbor)) {
             dfsFinishOrder(graph, neighbor, visited, finishOrder);
         }
@@ -340,7 +340,7 @@ function dfsCollectComponent(
     visited.add(node);
     component.push(node);
 
-    for (const neighbor of graph.neighbors(node)) {
+    for (const neighbor of Array.from(graph.neighbors(node))) {
         if (!visited.has(neighbor)) {
             dfsCollectComponent(graph, neighbor, visited, component);
         }
@@ -354,12 +354,12 @@ function createTransposeGraph(graph: Graph): Graph {
     const transpose = new Graph({directed: true});
 
     // Add all nodes
-    for (const node of graph.nodes()) {
+    for (const node of Array.from(graph.nodes())) {
         transpose.addNode(node.id, node.data);
     }
 
     // Add reverse edges
-    for (const edge of graph.edges()) {
+    for (const edge of Array.from(graph.edges())) {
         transpose.addEdge(edge.target, edge.source, edge.weight, edge.data);
     }