fix: resolve ruff linting, naming, and type hint issues

Author: gangs2314

fix_ruff_errors.py

@@ -0,0 +1,167 @@
+#!/usr/bin/env python3
+"""
+Auto-fix script for TheAlgorithms/Python PR ruff errors.
+Run from repo root: python fix_ruff_errors.py
+"""
+
+from pathlib import Path
+
+
+def fix_floyd_warshall():
+    p = Path("graphs/floyd_warshall.py")
+    text = p.read_text()
+    text = text.replace(
+        'current = next_node[current][end]  # type: ignore',
+        'current = next_node[current][end]  # type: ignore[assignment]'
+    )
+    p.write_text(text)
+    print("fixed graphs/floyd_warshall.py")
+
+
+def fix_ford_fulkerson():
+    p = Path("graphs/ford_fulkerson.py")
+    text = p.read_text()
+    text = text.replace(
+        'u = parent[s]  # type: ignore',
+        'u = parent[s]  # type: ignore[assignment]'
+    )
+    p.write_text(text)
+    print("fixed graphs/ford_fulkerson.py")
+
+
+def fix_heavy_light_decomposition():
+    p = Path("graphs/heavy_light_decomposition.py")
+    text = p.read_text()
+    old = """        # Same chain now
+        l, r = self.pos[u], self.pos[v]
+        if l > r:
+            l, r = r, l
+        segment = self.base_array[l : r + 1]"""
+    new = """        # Same chain now
+        left_idx, right_idx = self.pos[u], self.pos[v]
+        if left_idx > right_idx:
+            left_idx, right_idx = right_idx, left_idx
+        segment = self.base_array[left_idx : right_idx + 1]"""
+    text = text.replace(old, new)
+    p.write_text(text)
+    print("fixed graphs/heavy_light_decomposition.py")
+
+
+def fix_hopcroft_karp():
+    p = Path("graphs/hopcroft_karp.py")
+    text = p.read_text()
+
+    text = text.replace(
+        'self.dist[u] = float("inf")  # type: ignore',
+        'self.dist[u] = float("inf")  # type: ignore[assignment]',
+        1
+    )
+    text = text.replace(
+        'if pair_v is not None and self.dist[pair_v] == float("inf"):  # type: ignore',
+        'if pair_v is not None and self.dist[pair_v] == float("inf"):  # type: ignore[operator]'
+    )
+    text = text.replace(
+        'self.dist[u] = float("inf")  # type: ignore',
+        'self.dist[u] = float("inf")  # type: ignore[assignment]'
+    )
+
+    old = """                if self.pair_u[u] is None:
+                    if self.dfs(u):
+                        matching += 1"""
+    new = """                if self.pair_u[u] is None and self.dfs(u):
+                    matching += 1"""
+    text = text.replace(old, new)
+
+    old = """        print(
+            f"Hopcroft-Karp: {n}x{m}, {edges} edges, matching={result}, time={elapsed:.3f}s"
+        )"""
+    new = """        print(
+            f"Hopcroft-Karp: {n}x{m}, {edges} edges, "
+            f"matching={result}, time={elapsed:.3f}s"
+        )"""
+    text = text.replace(old, new)
+
+    p.write_text(text)
+    print("fixed graphs/hopcroft_karp.py")
+
+
+def fix_max_bipartite_independent_set():
+    p = Path("graphs/max_bipartite_independent_set.py")
+    text = p.read_text()
+
+    text = text.replace(
+        '# Minimum vertex cover = (U - Z) \u222a (V \u2229 Z)',
+        '# Minimum vertex cover = (U - Z) union (V intersect Z)'
+    )
+    text = text.replace(
+        '# Maximum independent set = Z \u222a (V - Z) = complement of min vertex cover',
+        '# Maximum independent set = Z union (V - Z) = complement of min vertex cover'
+    )
+    text = text.replace(
+        'dist[u] = float("inf")  # type: ignore',
+        'dist[u] = float("inf")  # type: ignore[assignment]',
+        1
+    )
+    text = text.replace(
+        'if pu is not None and dist[pu] == float("inf"):  # type: ignore',
+        'if pu is not None and dist[pu] == float("inf"):  # type: ignore[operator]'
+    )
+    text = text.replace(
+        'dist[u] = float("inf")  # type: ignore',
+        'dist[u] = float("inf")  # type: ignore[assignment]'
+    )
+
+    p.write_text(text)
+    print("fixed graphs/max_bipartite_independent_set.py")
+
+
+def fix_push_relabel():
+    p = Path("graphs/push_relabel.py")
+    text = p.read_text()
+
+    old = 'v for v in range(n) if v != source and v != sink and self.excess[v] > 0'
+    new = 'v for v in range(n) if v not in (source, sink) and self.excess[v] > 0'
+    text = text.replace(old, new)
+
+    old = """                    if (
+                        v != source
+                        and v != sink
+                        and self.excess[v] == self.excess[u] + 1
+                    ):"""
+    new = """                    if (
+                        v not in (source, sink)
+                        and self.excess[v] == self.excess[u] + 1
+                    ):"""
+    text = text.replace(old, new)
+
+    p.write_text(text)
+    print("fixed graphs/push_relabel.py")
+
+
+def fix_test_graph_algorithms():
+    p = Path("graphs/tests/test_graph_algorithms.py")
+    text = p.read_text()
+
+    text = text.replace(
+        'dist, next_node = floyd_warshall(graph)',
+        '_dist, next_node = floyd_warshall(graph)'
+    )
+    text = text.replace(
+        'result = hk.max_matching()',
+        'hk.max_matching()'
+    )
+
+    p.write_text(text)
+    print("fixed graphs/tests/test_graph_algorithms.py")
+
+
+if __name__ == "__main__":
+    print("Applying auto-fixes for ruff errors...\n")
+    fix_floyd_warshall()
+    fix_ford_fulkerson()
+    fix_heavy_light_decomposition()
+    fix_hopcroft_karp()
+    fix_max_bipartite_independent_set()
+    fix_push_relabel()
+    fix_test_graph_algorithms()
+    print("\nAll fixes applied! Run 'ruff check graphs/' to verify.")

graphs/basic_graphs.py

@@ -257,7 +257,7 @@ def adjm():
 
 
 def floy(a_and_n):
-    (a, n) = a_and_n
+    a, n = a_and_n
     dist = list(a)
     path = [[0] * n for i in range(n)]
     for k in range(n):
@@ -351,7 +351,7 @@ def krusk(e_and_n):
     """
     Sort edges on the basis of distance
     """
-    (e, n) = e_and_n
+    e, n = e_and_n
     e.sort(reverse=True, key=lambda x: x[2])
     s = [{i} for i in range(1, n + 1)]
     while True:

graphs/chinese_postman.py

@@ -9,9 +9,6 @@
 Space Complexity: O(V²)
 """
 
-from typing import List, Tuple, Dict, Set
-import itertools
-
 
 class ChinesePostman:
     """
@@ -20,7 +17,7 @@ class ChinesePostman:
 
     def __init__(self, n: int):
         self.n = n
-        self.adj: List[List[Tuple[int, int]]] = [[] for _ in range(n)]
+        self.adj: list[list[tuple[int, int]]] = [[] for _ in range(n)]
         self.total_weight = 0
 
     def add_edge(self, u: int, v: int, w: int) -> None:
@@ -29,7 +26,7 @@ def add_edge(self, u: int, v: int, w: int) -> None:
         self.adj[v].append((u, w))
         self.total_weight += w
 
-    def _floyd_warshall(self) -> List[List[float]]:
+    def _floyd_warshall(self) -> list[list[float]]:
         """All-pairs shortest paths."""
         n = self.n
         dist = [[float("inf")] * n for _ in range(n)]
@@ -44,12 +41,11 @@ def _floyd_warshall(self) -> List[List[float]]:
         for k in range(n):
             for i in range(n):
                 for j in range(n):
-                    if dist[i][k] + dist[k][j] < dist[i][j]:
-                        dist[i][j] = dist[i][k] + dist[k][j]
+                    dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j])
 
         return dist
 
-    def _find_odd_degree_vertices(self) -> List[int]:
+    def _find_odd_degree_vertices(self) -> list[int]:
         """Find vertices with odd degree."""
         odd = []
         for u in range(self.n):
@@ -58,7 +54,7 @@ def _find_odd_degree_vertices(self) -> List[int]:
         return odd
 
     def _min_weight_perfect_matching(
-        self, odd_vertices: List[int], dist: List[List[float]]
+        self, odd_vertices: list[int], dist: list[list[float]]
     ) -> float:
         """
         Find minimum weight perfect matching on odd degree vertices.
@@ -69,7 +65,7 @@ def _min_weight_perfect_matching(
             return 0
 
         # Dynamic programming: dp[mask] = min cost to match vertices in mask
-        dp: Dict[int, float] = {0: 0}
+        dp: dict[int, float] = {0: 0}
 
         for mask in range(1 << k):
             if bin(mask).count("1") % 2 == 1:
@@ -97,7 +93,7 @@ def _min_weight_perfect_matching(
         full_mask = (1 << k) - 1
         return dp.get(full_mask, 0)
 
-    def solve(self) -> Tuple[float, List[int]]:
+    def solve(self) -> tuple[float, list[int]]:
         """
         Solve Chinese Postman Problem.
 
@@ -137,16 +133,14 @@ def solve(self) -> Tuple[float, List[int]]:
         return float(self.total_weight + matching_cost), circuit
 
     def _add_matching_edges(
-        self, odd_vertices: List[int], dist: List[List[float]]
+        self, odd_vertices: list[int], dist: list[list[float]]
     ) -> None:
         """Duplicate edges based on minimum matching (simplified)."""
         # In practice, reconstruct path and add edges
         # For this implementation, we assume edges can be duplicated
-        pass
 
-    def _find_eulerian_circuit(self) -> List[int]:
+    def _find_eulerian_circuit(self) -> list[int]:
         """Find Eulerian circuit using Hierholzer's algorithm."""
-        n = self.n
         adj_copy = [list(neighbors) for neighbors in self.adj]
         circuit = []
         stack = [0]
@@ -168,8 +162,8 @@ def _find_eulerian_circuit(self) -> List[int]:
 
 
 def chinese_postman(
-    n: int, edges: List[Tuple[int, int, int]]
-) -> Tuple[float, List[int]]:
+    n: int, edges: list[tuple[int, int, int]]
+) -> tuple[float, list[int]]:
     """
     Convenience function for Chinese Postman.
 

graphs/dijkstra.py

@@ -48,7 +48,7 @@ def dijkstra(graph, start, end):
     heap = [(0, start)]  # cost from start node,end node
     visited = set()
     while heap:
-        (cost, u) = heapq.heappop(heap)
+        cost, u = heapq.heappop(heap)
         if u in visited:
             continue
         visited.add(u)

graphs/dijkstra_binary_grid.py

@@ -57,7 +57,7 @@ def dijkstra(
     predecessors[source] = None
 
     while queue:
-        (dist, (x, y)) = heappop(queue)
+        dist, (x, y) = heappop(queue)
         if (x, y) in visited:
             continue
         visited.add((x, y))

graphs/floyd_warshall.py

@@ -8,12 +8,10 @@
 Space Complexity: O(V²)
 """
 
-from typing import List, Tuple, Optional
-
 
 def floyd_warshall(
-    graph: List[List[float]],
-) -> Tuple[List[List[float]], List[List[Optional[int]]]]:
+    graph: list[list[float]],
+) -> tuple[list[list[float]], list[list[int | None]]]:
     """
     Compute all-pairs shortest paths using Floyd-Warshall algorithm.
 
@@ -61,8 +59,8 @@ def floyd_warshall(
 
 
 def reconstruct_path(
-    next_node: List[List[Optional[int]]], start: int, end: int
-) -> Optional[List[int]]:
+    next_node: list[list[int | None]], start: int, end: int
+) -> list[int] | None:
     """
     Reconstruct shortest path from start to end using next_node matrix.
 
@@ -75,13 +73,13 @@ def reconstruct_path(
     current = start
 
     while current != end:
-        current = next_node[current][end]  # type: ignore
+        current = next_node[current][end]
         path.append(current)
 
     return path
 
 
-def floyd_warshall_optimized(graph: List[List[float]]) -> List[List[float]]:
+def floyd_warshall_optimized(graph: list[list[float]]) -> list[list[float]]:
     """
     Space-optimized version using only distance matrix.
     Use when path reconstruction is not needed.
@@ -100,8 +98,7 @@ def floyd_warshall_optimized(graph: List[List[float]]) -> List[List[float]]:
                 if dist[k][j] == float("inf"):
                     continue
                 new_dist = dist[i][k] + dist[k][j]
-                if new_dist < dist[i][j]:
-                    dist[i][j] = new_dist
+                dist[i][j] = min(dist[i][j], new_dist)
 
     return dist