Improved Bellman-Ford Algorithm : Added Path Reconstruction With Better Output Representation

graphs/bellman_ford.py

@@ -1,73 +1,103 @@
-from __future__ import annotations
+from typing import List, Tuple, Dict
+from collections import namedtuple
+
+Edge = namedtuple("Edge", ["src", "dst", "weight"])
 
 
-def print_distance(distance: list[float], src):
+def print_distance_and_paths(distance: List[float], paths: List[List[int]], src: int):
-    print(f"Vertex\tShortest Distance from vertex {src}")
+    """
-    for i, d in enumerate(distance):
+    Prints the shortest distance and paths from the source vertex to each vertex.
-        print(f"{i}\t\t{d}")
+    """
+    print(f"Vertex\tShortest Distance from Vertex {src}\tPath")
+    for vertex, (dist, path) in enumerate(zip(distance, paths)):
+        path_str = " -> ".join(map(str, path)) if path else "No path"
+        print(f"{vertex}\t\t{dist}\t\t\t\t{path_str}")
 
 
-def check_negative_cycle(
+def check_negative_cycle(graph: List[Edge], distance: List[float], predecessor: List[int]) -> bool:
-    graph: list[dict[str, int]], distance: list[float], edge_count: int
+    """
-):
+    Checks if there is a negative weight cycle reachable from the source vertex.
-    for j in range(edge_count):
+    If found, return True, indicating a negative cycle.
-        u, v, w = (graph[j][k] for k in ["src", "dst", "weight"])
+    """
-        if distance[u] != float("inf") and distance[u] + w < distance[v]:
+    for edge in graph:
+        if distance[edge.src] != float("inf") and distance[edge.src] + edge.weight < distance[edge.dst]:
+            # Update predecessors to indicate a cycle for affected paths
+            predecessor[edge.dst] = -1  # Use -1 as a marker for negative cycle detection
             return True
     return False
 
 
-def bellman_ford(
+def reconstruct_paths(predecessor: List[int], vertex_count: int, src: int) -> List[List[int]]:
-    graph: list[dict[str, int]], vertex_count: int, edge_count: int, src: int
-) -> list[float]:
     """
-    Returns shortest paths from a vertex src to all
+    Reconstructs the shortest paths from the source vertex to each vertex using the predecessor list.
-    other vertices.
+    """
-    >>> edges = [(2, 1, -10), (3, 2, 3), (0, 3, 5), (0, 1, 4)]
+    paths = [[] for _ in range(vertex_count)]
-    >>> g = [{"src": s, "dst": d, "weight": w} for s, d, w in edges]
+    for vertex in range(vertex_count):
-    >>> bellman_ford(g, 4, 4, 0)
+        if predecessor[vertex] == -1:
-    [0.0, -2.0, 8.0, 5.0]
+            paths[vertex] = ["Negative cycle detected"]
-    >>> g = [{"src": s, "dst": d, "weight": w} for s, d, w in edges + [(1, 3, 5)]]
+        elif predecessor[vertex] is not None:
-    >>> bellman_ford(g, 4, 5, 0)
+            path = []
-    Traceback (most recent call last):
+            current = vertex
-     ...
+            while current is not None:
-    Exception: Negative cycle found
+                path.insert(0, current)
+                if current == src:
+                    break
+                current = predecessor[current]
+            paths[vertex] = path
+    return paths
+
+
+def bellman_ford(graph: List[Edge], vertex_count: int, src: int) -> Tuple[List[float], List[List[int]]]:
+    """
+    Returns the shortest paths from a vertex src to all other vertices, including path reconstruction.
     """
     distance = [float("inf")] * vertex_count
+    predecessor = [None] * vertex_count  # Keeps track of the path predecessors
     distance[src] = 0.0
 
+    # Step 1: Relax edges repeatedly
     for _ in range(vertex_count - 1):
-        for j in range(edge_count):
+        for edge in graph:
-            u, v, w = (graph[j][k] for k in ["src", "dst", "weight"])
+            if distance[edge.src] != float("inf") and distance[edge.src] + edge.weight < distance[edge.dst]:
+                distance[edge.dst] = distance[edge.src] + edge.weight
+                predecessor[edge.dst] = edge.src
 
-            if distance[u] != float("inf") and distance[u] + w < distance[v]:
+    # Step 2: Check for negative weight cycles
-                distance[v] = distance[u] + w
+    if check_negative_cycle(graph, distance, predecessor):
-
-    negative_cycle_exists = check_negative_cycle(graph, distance, edge_count)
-    if negative_cycle_exists:
         raise Exception("Negative cycle found")
 
-    return distance
+    # Step 3: Reconstruct paths from predecessor list
+    paths = reconstruct_paths(predecessor, vertex_count, src)
+
+    return distance, paths
 
 
 if __name__ == "__main__":
+    # Example graph input for testing purposes
     import doctest
-
     doctest.testmod()
 
+    try:
         V = int(input("Enter number of vertices: ").strip())
         E = int(input("Enter number of edges: ").strip())
 
-    graph: list[dict[str, int]] = [{} for _ in range(E)]
+        graph: List[Edge] = []
 
         for i in range(E):
-        print("Edge ", i + 1)
+            print(f"Edge {i + 1}")
-        src, dest, weight = (
+            src, dest, weight = map(int, input("Enter source, destination, weight: ").strip().split())
-            int(x)
+            if src < 0 or src >= V or dest < 0 or dest >= V:
-            for x in input("Enter source, destination, weight: ").strip().split(" ")
+                print(f"Invalid vertices: src and dest should be between 0 and {V - 1}")
-        )
+                continue
-        graph[i] = {"src": src, "dst": dest, "weight": weight}
+            graph.append(Edge(src, dest, weight))
 
-    source = int(input("\nEnter shortest path source:").strip())
+        source = int(input("\nEnter shortest path source vertex: ").strip())
-    shortest_distance = bellman_ford(graph, V, E, source)
+        if source < 0 or source >= V:
-    print_distance(shortest_distance, 0)
+            print(f"Invalid source: source should be between 0 and {V - 1}")
+        else:
+            shortest_distance, paths = bellman_ford(graph, V, source)
+            print_distance_and_paths(shortest_distance, paths, source)
+    except ValueError:
+        print("Please enter valid integer inputs.")
+    except Exception as e:
+        print(e)