change ford_fulkerson.py

Author: lighting9999

networking_flow/ford_fulkerson.py

@@ -7,6 +7,9 @@
     (2) Choose the augmenting path from source to sink and add the path to flow
 """
 
+from collections import deque
+from typing import List
+
 graph = [
     [0, 16, 13, 0, 0, 0],
     [0, 0, 10, 12, 0, 0],
@@ -17,7 +20,7 @@
 ]
 
 
-def breadth_first_search(graph: list, source: int, sink: int, parents: list) -> bool:
+def breadth_first_search(graph: List[List[int]], source: int, sink: int, parents: List[int]) -> bool:
     """
     This function returns True if there is a node that has not iterated.
 
@@ -37,25 +40,31 @@ def breadth_first_search(graph: list, source: int, sink: int, parents: list) ->
         ...
     IndexError: list index out of range
     """
-    visited = [False] * len(graph)  # Mark all nodes as not visited
-    queue = []  # breadth-first search queue
-
-    # Source node
+    num_nodes = len(graph)
+    visited = [False] * num_nodes
+    queue = deque()
+    
     queue.append(source)
     visited[source] = True
-
+    
     while queue:
-        u = queue.pop(0)  # Pop the front node
-        # Traverse all adjacent nodes of u
-        for ind, node in enumerate(graph[u]):
-            if visited[ind] is False and node > 0:
-                queue.append(ind)
-                visited[ind] = True
-                parents[ind] = u
+        current_node = queue.popleft()
+        
+        # If we reached the sink, we can stop early
+        if current_node == sink:
+            return True
+            
+        # Check all adjacent nodes
+        for neighbor, capacity in enumerate(graph[current_node]):
+            if not visited[neighbor] and capacity > 0:
+                visited[neighbor] = True
+                parents[neighbor] = current_node
+                queue.append(neighbor)
+                
     return visited[sink]
 
 
-def ford_fulkerson(graph: list, source: int, sink: int) -> int:
+def ford_fulkerson(graph: List[List[int]], source: int, sink: int) -> int:
     """
     This function returns the maximum flow from source to sink in the given graph.
 
@@ -80,28 +89,34 @@ def ford_fulkerson(graph: list, source: int, sink: int) -> int:
     >>> ford_fulkerson(test_graph, 0, 5)
     23
     """
-    # This array is filled by breadth-first search and to store path
-    parent = [-1] * (len(graph))
+    # Create a copy of the graph to avoid modifying the original
+    residual_graph = [row[:] for row in graph]
+    num_nodes = len(residual_graph)
+    parents = [-1] * num_nodes
     max_flow = 0
 
-    # While there is a path from source to sink
-    while breadth_first_search(graph, source, sink, parent):
-        path_flow = int(1e9)  # Infinite value
-        s = sink
-
-        while s != source:
-            # Find the minimum value in the selected path
-            path_flow = min(path_flow, graph[parent[s]][s])
-            s = parent[s]
-
+    # Augment the flow while there is a path from source to sink
+    while breadth_first_search(residual_graph, source, sink, parents):
+        # Find the minimum residual capacity along the path
+        path_flow = float('inf')
+        current_node = sink
+        
+        # Find the minimum capacity in the path
+        while current_node != source:
+            parent_node = parents[current_node]
+            path_flow = min(path_flow, residual_graph[parent_node][current_node])
+            current_node = parent_node
+
+        # Add path flow to overall flow
         max_flow += path_flow
-        v = sink
 
-        while v != source:
-            u = parent[v]
-            graph[u][v] -= path_flow
-            graph[v][u] += path_flow
-            v = parent[v]
+        # Update residual capacities of the edges and reverse edges
+        current_node = sink
+        while current_node != source:
+            parent_node = parents[current_node]
+            residual_graph[parent_node][current_node] -= path_flow
+            residual_graph[current_node][parent_node] += path_flow
+            current_node = parent_node
 
     return max_flow