Address review: drop __future__ import, use descriptive names, apply README wording

Author: priya-sundaram-dev

networking_flow/README.md

@@ -1,8 +1,8 @@
 # Networking Flow
 
 This directory collects algorithms for the **maximum-flow problem**: given a
-directed graph whose edges have capacities, a *source* `s`, and a *sink* `t`,
-how much flow can be pushed from `s` to `t` without exceeding any edge's
+directed graph whose edges have capacities, a `source`, and a `sink`, how
+much flow can be pushed from `source` to `sink` without exceeding any edge's
 capacity?
 
 Maximum flow turns up all over the place — routing traffic through a network,

networking_flow/dinic.py

@@ -18,8 +18,6 @@
 Reference: https://en.wikipedia.org/wiki/Dinic%27s_algorithm
 """
 
-from __future__ import annotations
-
 from collections import deque
 
 
@@ -60,7 +58,7 @@ def __init__(self, vertices: int) -> None:
         if vertices <= 0:
             raise ValueError("number of vertices must be positive")
         self.size = vertices
-        # graph[u] holds indices into self.edges for edges leaving u.
+        # graph[vertex] holds indices into self.edges for edges leaving that vertex.
         self.graph: list[list[int]] = [[] for _ in range(vertices)]
         # Each edge is stored as [destination, residual_capacity].
         # Edge i and its reverse edge i ^ 1 are always created together.
@@ -96,37 +94,37 @@ def _build_level_graph(self, source: int) -> list[int]:
         level[source] = 0
         queue = deque([source])
         while queue:
-            u = queue.popleft()
-            for edge_index in self.graph[u]:
+            vertex = queue.popleft()
+            for edge_index in self.graph[vertex]:
                 destination, residual = self.edges[edge_index]
                 if residual > 0 and level[destination] == -1:
-                    level[destination] = level[u] + 1
+                    level[destination] = level[vertex] + 1
                     queue.append(destination)
         return level
 
     def _send_flow(
         self,
-        u: int,
+        vertex: int,
         pushed: int,
         sink: int,
         level: list[int],
         progress: list[int],
     ) -> int:
         """Depth-first search that pushes a blocking flow along the level graph."""
-        if u == sink:
+        if vertex == sink:
             return pushed
-        while progress[u] < len(self.graph[u]):
-            edge_index = self.graph[u][progress[u]]
+        while progress[vertex] < len(self.graph[vertex]):
+            edge_index = self.graph[vertex][progress[vertex]]
             destination, residual = self.edges[edge_index]
-            if residual > 0 and level[destination] == level[u] + 1:
+            if residual > 0 and level[destination] == level[vertex] + 1:
                 flow = self._send_flow(
                     destination, min(pushed, residual), sink, level, progress
                 )
                 if flow > 0:
                     self.edges[edge_index][1] -= flow
                     self.edges[edge_index ^ 1][1] += flow
                     return flow
-            progress[u] += 1
+            progress[vertex] += 1
         return 0
 
     def max_flow(self, source: int, sink: int) -> int:

networking_flow/minimum_cut.py

@@ -22,9 +22,9 @@
 ]
 
 
-def bfs(graph: list[list[int]], s: int, t: int, parent: list[int]) -> bool:
+def bfs(graph: list[list[int]], source: int, sink: int, parent: list[int]) -> bool:
     """
-    Return True if the sink ``t`` is reachable from the source ``s`` in the
+    Return True if the ``sink`` is reachable from the ``source`` in the
     residual ``graph``, recording the traversal tree in ``parent``.
 
     >>> bfs(test_graph, 0, 5, [-1] * 6)
@@ -33,18 +33,18 @@ def bfs(graph: list[list[int]], s: int, t: int, parent: list[int]) -> bool:
     False
     """
     visited = [False] * len(graph)
-    queue = [s]
-    visited[s] = True
+    queue = [source]
+    visited[source] = True
 
     while queue:
-        u = queue.pop(0)
-        for ind in range(len(graph[u])):
-            if visited[ind] is False and graph[u][ind] > 0:
-                queue.append(ind)
-                visited[ind] = True
-                parent[ind] = u
-
-    return visited[t]
+        node = queue.pop(0)
+        for neighbor in range(len(graph[node])):
+            if visited[neighbor] is False and graph[node][neighbor] > 0:
+                queue.append(neighbor)
+                visited[neighbor] = True
+                parent[neighbor] = node
+
+    return visited[sink]
 
 
 def mincut(graph: list[list[int]], source: int, sink: int) -> list[tuple[int, int]]: