Implement the optimal stack queue implementation in the edmond karp algorithm

Author: mapcrafter2048

graph/edmonds_karp.ts

@@ -1,3 +1,5 @@
+import { StackQueue } from "../data_structures/queue/stack_queue";
+
 /**
  * @function edmondsKarp
  * @description Compute the maximum flow from a source node to a sink node using the Edmonds-Karp algorithm.
@@ -10,87 +12,86 @@
  * @return {number} - The maximum flow from the source node to the sink node.
  * @see https://en.wikipedia.org/wiki/Edmonds%E2%80%93Karp_algorithm
  */
-
 export default function edmondsKarp(
   graph: [number, number][][],
   source: number,
   sink: number
 ): number {
-  const n = graph.length
+  const n = graph.length;
 
   // Initialize residual graph
   const residualGraph: [number, number][][] = Array.from(
     { length: n },
     () => []
-  )
+  );
 
   // Build residual graph from the original graph
   for (let u = 0; u < n; u++) {
     for (const [v, cap] of graph[u]) {
       if (cap > 0) {
-        residualGraph[u].push([v, cap]) // Forward edge
-        residualGraph[v].push([u, 0]) // Reverse edge with 0 capacity
+        residualGraph[u].push([v, cap]); // Forward edge
+        residualGraph[v].push([u, 0]); // Reverse edge with 0 capacity
       }
     }
   }
 
   const findAugmentingPath = (parent: (number | null)[]): number => {
-    const visited = Array(n).fill(false)
-    const queue: number[] = []
-    queue.push(source)
-    visited[source] = true
-    parent[source] = null
+    const visited = Array(n).fill(false);
+    const queue = new StackQueue<number>();
+    queue.enqueue(source);
+    visited[source] = true;
+    parent[source] = null;
 
-    while (queue.length > 0) {
-      const u = queue.shift()!
+    while (queue.length() > 0) {
+      const u = queue.dequeue();
       for (const [v, cap] of residualGraph[u]) {
         if (!visited[v] && cap > 0) {
-          parent[v] = u
-          visited[v] = true
+          parent[v] = u;
+          visited[v] = true;
           if (v === sink) {
             // Return the bottleneck capacity along the path
-            let pathFlow = Infinity
-            let current = v
+            let pathFlow = Infinity;
+            let current = v;
             while (parent[current] !== null) {
-              const prev = parent[current]!
+              const prev = parent[current]!;
               const edgeCap = residualGraph[prev].find(
                 ([node]) => node === current
-              )![1]
-              pathFlow = Math.min(pathFlow, edgeCap)
-              current = prev
+              )![1];
+              pathFlow = Math.min(pathFlow, edgeCap);
+              current = prev;
             }
-            return pathFlow
+            return pathFlow;
           }
-          queue.push(v)
+          queue.enqueue(v);
         }
       }
     }
-    return 0
-  }
+    return 0;
+  };
 
-  let maxFlow = 0
-  const parent = Array(n).fill(null)
+  let maxFlow = 0;
+  const parent = Array(n).fill(null);
 
   while (true) {
-    const pathFlow = findAugmentingPath(parent)
-    if (pathFlow === 0) break // No augmenting path found
+    const pathFlow = findAugmentingPath(parent);
+    if (pathFlow === 0) break; // No augmenting path found
 
     // Update the capacities and reverse capacities in the residual graph
-    let v = sink
+    let v = sink;
     while (parent[v] !== null) {
-      const u = parent[v]!
+      const u = parent[v]!;
       // Update capacity of the forward edge
-      const forwardEdge = residualGraph[u].find(([node]) => node === v)!
-      forwardEdge[1] -= pathFlow
+      const forwardEdge = residualGraph[u].find(([node]) => node === v)!;
+      forwardEdge[1] -= pathFlow;
       // Update capacity of the reverse edge
-      const reverseEdge = residualGraph[v].find(([node]) => node === u)!
-      reverseEdge[1] += pathFlow
+      const reverseEdge = residualGraph[v].find(([node]) => node === u)!;
+      reverseEdge[1] += pathFlow;
 
-      v = u
+      v = u;
     }
 
-    maxFlow += pathFlow
+    maxFlow += pathFlow;
   }
 
-  return maxFlow
+  return maxFlow;
 }