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

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

graphs/johnson_graph.py

@@ -2,85 +2,86 @@ from collections import deque
 import heapq
 import sys
 
-#First implementation of johnson algorithm
+
+# First implementation of johnson algorithm
 class JohnsonGraph:
     def __init__(self):
         self.edges = []
         self.graph = {}
-    
+
-    #add vertices for a graph
+    # add vertices for a graph
     def add_vertices(self, u):
         self.graph[u] = []
-    
+
-    #assign weights for each edges formed of the directed graph
+    # assign weights for each edges formed of the directed graph
     def add_edge(self, u, v, w):
         self.edges.append((u, v, w))
-        self.graph[u].append((v,w))
+        self.graph[u].append((v, w))
 
-    #perform a dijkstra algorithm on a directed graph
+    # perform a dijkstra algorithm on a directed graph
     def dijkstra(self, s):
         no_v = len(self.graph)
-        distances = {vertex: sys.maxsize-1 for vertex in self.graph}
+        distances = {vertex: sys.maxsize - 1 for vertex in self.graph}
-        pq = [(0,s)]
+        pq = [(0, s)]
-        
+
         distances[s] = 0
         while pq:
             weight, v = heapq.heappop(pq)
-            
+
             if weight > distances[v]:
                 continue
-                
+
             for node, w in self.graph[v]:
-                if distances[v]+w < distances[node]:
+                if distances[v] + w < distances[node]:
-                    distances[node] = distances[v]+w
+                    distances[node] = distances[v] + w
-                    heapq.heappush(pq, (distances[node], node)) 
+                    heapq.heappush(pq, (distances[node], node))
         return distances
 
-    #carry out the bellman ford algorithm for a node and estimate its distance vector
+    # carry out the bellman ford algorithm for a node and estimate its distance vector
-    def bellman_ford(self, s): 
+    def bellman_ford(self, s):
         no_v = len(self.graph)
-        distances = {vertex: sys.maxsize-1 for vertex in self.graph}
+        distances = {vertex: sys.maxsize - 1 for vertex in self.graph}
         distances[s] = 0
-        
+
         for u in self.graph:
             for u, v, w in self.edges:
-                if distances[u] != sys.maxsize-1 and distances[u]+w<distances[v]:
+                if distances[u] != sys.maxsize - 1 and distances[u] + w < distances[v]:
-                    distances[v] = distances[u]+w
+                    distances[v] = distances[u] + w
 
         return distances
- 
+
-    #perform the johnson algorithm to handle the negative weights that could not be handled by either the dijkstra
+    # perform the johnson algorithm to handle the negative weights that could not be handled by either the dijkstra
-    #or the bellman ford algorithm efficiently
+    # or the bellman ford algorithm efficiently
     def johnson_algo(self):
-        
         self.add_vertices("#")
         for v in self.graph:
             if v != "#":
                 self.add_edge("#", v, 0)
-            
+
         n = self.bellman_ford("#")
-        
+
         for i in range(len(self.edges)):
             u, v, weight = self.edges[i]
             self.edges[i] = (u, v, weight + n[u] - n[v])
 
         self.graph.pop("#")
         self.edges = [(u, v, w) for u, v, w in self.edges if u != "#"]
-        
+
         for u in self.graph:
             self.graph[u] = [(v, weight) for x, v, weight in self.edges if x == u]
-        
+
         distances = []
         for u in self.graph:
             new_dist = self.dijkstra(u)
             for v in self.graph:
-                if new_dist[v] < sys.maxsize-1:
+                if new_dist[v] < sys.maxsize - 1:
                     new_dist[v] += n[v] - n[u]
             distances.append(new_dist)
         return distances
-        
+
+
 g = JohnsonGraph()
-#this a complete connected graph
+# this a complete connected graph
 g.add_vertices("A")
 g.add_vertices("B")
 g.add_vertices("C")
@@ -97,4 +98,4 @@ g.add_edge("E", "C", -2)
 optimal_paths = g.johnson_algo()
 print("Print all optimal paths of a graph using Johnson Algorithm")
 for i, row in enumerate(optimal_paths):
-    print(f"{i}: {row}")
+    print(f"{i}: {row}")