[pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

Author: pre-commit-ci[bot]

graphs/chinese_postman.py

@@ -17,92 +17,93 @@ class ChinesePostman:
     """
     Solve Chinese Postman Problem for weighted undirected graphs.
     """
-    
+
     def __init__(self, n: int):
         self.n = 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:
         """Add undirected edge."""
         self.adj[u].append((v, w))
         self.adj[v].append((u, w))
         self.total_weight += w
-    
+
     def _floyd_warshall(self) -> List[List[float]]:
         """All-pairs shortest paths."""
         n = self.n
-        dist = [[float('inf')] * n for _ in range(n)]
-        
+        dist = [[float("inf")] * n for _ in range(n)]
+
         for i in range(n):
             dist[i][i] = 0
-        
+
         for u in range(n):
             for v, w in self.adj[u]:
                 dist[u][v] = min(dist[u][v], w)
-        
+
         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]
-        
+
         return dist
-    
+
     def _find_odd_degree_vertices(self) -> List[int]:
         """Find vertices with odd degree."""
         odd = []
         for u in range(self.n):
             if len(self.adj[u]) % 2 == 1:
                 odd.append(u)
         return odd
-    
-    def _min_weight_perfect_matching(self, odd_vertices: List[int], 
-                                     dist: List[List[float]]) -> float:
+
+    def _min_weight_perfect_matching(
+        self, odd_vertices: List[int], dist: List[List[float]]
+    ) -> float:
         """
         Find minimum weight perfect matching on odd degree vertices.
         Uses brute force for small k (k <= 20), which is practical.
         """
         k = len(odd_vertices)
         if k == 0:
             return 0
-        
+
         # Dynamic programming: dp[mask] = min cost to match vertices in mask
         dp: Dict[int, float] = {0: 0}
-        
+
         for mask in range(1 << k):
-            if bin(mask).count('1') % 2 == 1:
+            if bin(mask).count("1") % 2 == 1:
                 continue  # Odd number of bits, can't be perfectly matched
-            
+
             if mask not in dp:
                 continue
-            
+
             # Find first unset bit
             i = 0
             while i < k and (mask & (1 << i)):
                 i += 1
-            
+
             if i >= k:
                 continue
-            
+
             # Try matching i with every other unmatched vertex j
             for j in range(i + 1, k):
                 if not (mask & (1 << j)):
                     new_mask = mask | (1 << i) | (1 << j)
                     cost = dp[mask] + dist[odd_vertices[i]][odd_vertices[j]]
                     if new_mask not in dp or cost < dp[new_mask]:
                         dp[new_mask] = cost
-        
+
         full_mask = (1 << k) - 1
         return dp.get(full_mask, 0)
-    
+
     def solve(self) -> Tuple[float, List[int]]:
         """
         Solve Chinese Postman Problem.
-        
+
         Returns:
             Tuple of (minimum_cost, eulerian_circuit)
-        
+
         Example:
             >>> cpp = ChinesePostman(4)
             >>> cpp.add_edge(0, 1, 1)
@@ -115,40 +116,41 @@ def solve(self) -> Tuple[float, List[int]]:
         """
         # Find odd degree vertices
         odd_vertices = self._find_odd_degree_vertices()
-        
+
         # Graph is already Eulerian
         if len(odd_vertices) == 0:
             circuit = self._find_eulerian_circuit()
             return float(self.total_weight), circuit
-        
+
         # Compute all-pairs shortest paths
         dist = self._floyd_warshall()
-        
+
         # Find minimum weight matching
         matching_cost = self._min_weight_perfect_matching(odd_vertices, dist)
-        
+
         # Duplicate edges from matching to make graph Eulerian
         self._add_matching_edges(odd_vertices, dist)
-        
+
         # Find Eulerian circuit
         circuit = self._find_eulerian_circuit()
-        
+
         return float(self.total_weight + matching_cost), circuit
-    
-    def _add_matching_edges(self, odd_vertices: List[int], 
-                           dist: List[List[float]]) -> None:
+
+    def _add_matching_edges(
+        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]:
         """Find Eulerian circuit using Hierholzer's algorithm."""
         n = self.n
         adj_copy = [list(neighbors) for neighbors in self.adj]
         circuit = []
         stack = [0]
-        
+
         while stack:
             u = stack[-1]
             if adj_copy[u]:
@@ -161,18 +163,20 @@ def _find_eulerian_circuit(self) -> List[int]:
                 stack.append(v)
             else:
                 circuit.append(stack.pop())
-        
+
         return circuit[::-1]
 
 
-def chinese_postman(n: int, edges: List[Tuple[int, int, int]]) -> Tuple[float, List[int]]:
+def chinese_postman(
+    n: int, edges: List[Tuple[int, int, int]]
+) -> Tuple[float, List[int]]:
     """
     Convenience function for Chinese Postman.
-    
+
     Args:
         n: Number of vertices
         edges: List of (u, v, weight) undirected edges
-    
+
     Returns:
         (minimum_cost, eulerian_circuit)
     """
@@ -184,4 +188,5 @@ def chinese_postman(n: int, edges: List[Tuple[int, int, int]]) -> Tuple[float, L
 
 if __name__ == "__main__":
     import doctest
-    doctest.testmod()
+
+    doctest.testmod()

graphs/floyd_warshall.py

@@ -11,19 +11,21 @@
 from typing import List, Tuple, Optional
 
 
-def floyd_warshall(graph: List[List[float]]) -> Tuple[List[List[float]], List[List[Optional[int]]]]:
+def floyd_warshall(
+    graph: List[List[float]],
+) -> Tuple[List[List[float]], List[List[Optional[int]]]]:
     """
     Compute all-pairs shortest paths using Floyd-Warshall algorithm.
-    
+
     Args:
         graph: Adjacency matrix where graph[i][j] is weight from i to j.
                Use float('inf') for no edge. graph[i][i] should be 0.
-    
+
     Returns:
         Tuple of (distance_matrix, next_matrix)
         - distance_matrix[i][j] = shortest distance from i to j
         - next_matrix[i][j] = next node to visit from i to reach j optimally
-    
+
     Example:
         >>> graph = [[0, 3, float('inf'), 7],
         ...          [8, 0, 2, float('inf')],
@@ -34,90 +36,96 @@ def floyd_warshall(graph: List[List[float]]) -> Tuple[List[List[float]], List[Li
         6
     """
     n = len(graph)
-    
+
     # Initialize distance and path matrices
     dist = [row[:] for row in graph]  # Deep copy
-    next_node = [[j if graph[i][j] != float('inf') and i != j else None 
-                  for j in range(n)] for i in range(n)]
-    
+    next_node = [
+        [j if graph[i][j] != float("inf") and i != j else None for j in range(n)]
+        for i in range(n)
+    ]
+
     # Main algorithm: try each vertex as intermediate
     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]
                     next_node[i][j] = next_node[i][k]
-    
+
     # Check for negative cycles
     for i in range(n):
         if dist[i][i] < 0:
             raise ValueError("Graph contains negative weight cycle")
-    
+
     return dist, next_node
 
 
-def reconstruct_path(next_node: List[List[Optional[int]]], 
-                     start: int, end: int) -> Optional[List[int]]:
+def reconstruct_path(
+    next_node: List[List[Optional[int]]], start: int, end: int
+) -> Optional[List[int]]:
     """
     Reconstruct shortest path from start to end using next_node matrix.
-    
+
     Time Complexity: O(V)
     """
     if next_node[start][end] is None:
         return None
-    
+
     path = [start]
     current = start
-    
+
     while current != end:
         current = next_node[current][end]  # type: ignore
         path.append(current)
-    
+
     return path
 
 
 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.
-    
+
     Time Complexity: O(V³)
     Space Complexity: O(V²) but less overhead
     """
     n = len(graph)
     dist = [row[:] for row in graph]
-    
+
     for k in range(n):
         for i in range(n):
-            if dist[i][k] == float('inf'):
+            if dist[i][k] == float("inf"):
                 continue
             for j in range(n):
-                if dist[k][j] == float('inf'):
+                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
-    
+
     return dist
 
 
 if __name__ == "__main__":
     import doctest
+
     doctest.testmod()
-    
+
     # Performance benchmark
     import random
     import time
-    
+
     def benchmark():
         n = 200
         # Generate random dense graph
-        graph = [[0 if i == j else random.randint(1, 100) 
-                 for j in range(n)] for i in range(n)]
-        
+        graph = [
+            [0 if i == j else random.randint(1, 100) for j in range(n)]
+            for i in range(n)
+        ]
+
         start = time.perf_counter()
         floyd_warshall(graph)
         elapsed = time.perf_counter() - start
         print(f"Floyd-Warshall on {n}x{n} graph: {elapsed:.3f}s")
-    
-    benchmark()
+
+    benchmark()