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

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

Author: pre-commit-ci[bot]

graphs/travlelling_salesman_problem.py

@@ -1,8 +1,9 @@
 """
-title : Travelling Sales man Problem 
+title : Travelling Sales man Problem
 references : https://en.wikipedia.org/wiki/Travelling_salesman_problem
 author : SunayBhoyar
 """
+
 import itertools
 import math
 
@@ -13,10 +14,11 @@
     "D": [40, 10],
     "E": [25, 5],
     "F": [5, 15],
-    "G": [50, 25]
+    "G": [50, 25],
 }
 
-# Euclidean distance - shortest distance between 2 points 
+
+# Euclidean distance - shortest distance between 2 points
 def distance(point1, point2):
     """
     Calculate the Euclidean distance between two points.
@@ -28,11 +30,14 @@ def distance(point1, point2):
     """
     return math.sqrt((point2[0] - point1[0]) ** 2 + (point2[1] - point1[1]) ** 2)
 
+
 """
-Brute force 
+Brute force
 Time Complexity - O(n!×n)
 Space Complexity - O(n)
 """
+
+
 def travelling_sales_man_problem_brute_force(graph_points):
     """
     Solve the Travelling Salesman Problem using brute force (permutations).
@@ -43,31 +48,34 @@ def travelling_sales_man_problem_brute_force(graph_points):
     (['A', 'B', 'C', 'A'], 3.414)
     """
     nodes = list(graph_points.keys())
-    
+
     min_path = None
-    min_distance = float('inf')
-    
-    # Considering the first Node as the start position 
+    min_distance = float("inf")
+
+    # Considering the first Node as the start position
     start_node = nodes[0]
     other_nodes = nodes[1:]
-    
+
     for perm in itertools.permutations(other_nodes):
         path = [start_node] + list(perm) + [start_node]
         total_distance = 0
         for i in range(len(path) - 1):
-            total_distance += distance(graph_points[path[i]], graph_points[path[i+1]])
+            total_distance += distance(graph_points[path[i]], graph_points[path[i + 1]])
 
         if total_distance < min_distance:
             min_distance = total_distance
             min_path = path
-    
+
     return min_path, min_distance
 
+
 """
-dynamic_programming 
+dynamic_programming
 Time Complexity - O(n^2×2^n)
 Space Complexity - O(n×2^n)
 """
+
+
 def travelling_sales_man_problem_dp(graph_points):
     """
     Solve the Travelling Salesman Problem using dynamic programming.
@@ -79,57 +87,65 @@ def travelling_sales_man_problem_dp(graph_points):
     """
     n = len(graph_points)
     nodes = list(graph_points.keys())
-    
+
     # Precompute distances between every pair of nodes
     dist = [[0] * n for _ in range(n)]
     for i in range(n):
         for j in range(n):
             dist[i][j] = distance(graph_points[nodes[i]], graph_points[nodes[j]])
-    
+
     # dp[mask][i] represents the minimum distance to visit all nodes in the 'mask' set, ending at node i
-    dp = [[float('inf')] * n for _ in range(1 << n)]
+    dp = [[float("inf")] * n for _ in range(1 << n)]
     dp[1][0] = 0  # Start at node 0
-    
+
     # Iterate over all subsets of nodes (represented by mask)
     for mask in range(1 << n):
         for u in range(n):
-            if mask & (1 << u): 
+            if mask & (1 << u):
                 for v in range(n):
-                    if mask & (1 << v) == 0:  
+                    if mask & (1 << v) == 0:
                         next_mask = mask | (1 << v)
-                        dp[next_mask][v] = min(dp[next_mask][v], dp[mask][u] + dist[u][v])
+                        dp[next_mask][v] = min(
+                            dp[next_mask][v], dp[mask][u] + dist[u][v]
+                        )
 
     # Reconstruct the path and find the minimum distance to return to the start
     final_mask = (1 << n) - 1
-    min_cost = float('inf')
+    min_cost = float("inf")
     end_node = -1
 
     # Find the minimum distance from any node back to the starting node
     for u in range(1, n):
         if min_cost > dp[final_mask][u] + dist[u][0]:
             min_cost = dp[final_mask][u] + dist[u][0]
             end_node = u
-    
+
     # Reconstruct the path using the dp table
     path = []
     mask = final_mask
     while end_node != 0:
         path.append(nodes[end_node])
         for u in range(n):
-            if mask & (1 << u) and dp[mask][end_node] == dp[mask ^ (1 << end_node)][u] + dist[u][end_node]:
-                mask ^= (1 << end_node) 
+            if (
+                mask & (1 << u)
+                and dp[mask][end_node]
+                == dp[mask ^ (1 << end_node)][u] + dist[u][end_node]
+            ):
+                mask ^= 1 << end_node
                 end_node = u
                 break
 
-    path.append(nodes[0])  
+    path.append(nodes[0])
     path.reverse()
 
     return path, min_cost
 
 
 if __name__ == "__main__":
     print(f"Travelling salesman problem solved using Brute Force:")
-    path, distance_travelled = travelling_sales_man_problem_brute_force(demo_graph_points)
+    path, distance_travelled = travelling_sales_man_problem_brute_force(
+        demo_graph_points
+    )
     print(f"Shortest path: {path}")
     print(f"Total distance: {distance_travelled:.2f}")