From 2b50d97d3ef3531fa19855de3ef64292dca59bdf Mon Sep 17 00:00:00 2001 From: unknown Date: Fri, 11 Oct 2024 03:34:07 +0530 Subject: [PATCH 1/2] Improved Bellman-Ford Algorithm : Added Path Reconstruction With Better Output Representation --- graphs/bellman_ford.py | 124 +++++++++++++++++++++++++---------------- 1 file changed, 77 insertions(+), 47 deletions(-) diff --git a/graphs/bellman_ford.py b/graphs/bellman_ford.py index 9ac8bae85..f69572d90 100644 --- a/graphs/bellman_ford.py +++ b/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): - print(f"Vertex\tShortest Distance from vertex {src}") - for i, d in enumerate(distance): - print(f"{i}\t\t{d}") +def print_distance_and_paths(distance: List[float], paths: List[List[int]], src: int): + """ + Prints the shortest distance and paths from the source vertex to each vertex. + """ + 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( - graph: list[dict[str, int]], distance: list[float], edge_count: int -): - for j in range(edge_count): - u, v, w = (graph[j][k] for k in ["src", "dst", "weight"]) - if distance[u] != float("inf") and distance[u] + w < distance[v]: +def check_negative_cycle(graph: List[Edge], distance: List[float], predecessor: List[int]) -> bool: + """ + Checks if there is a negative weight cycle reachable from the source vertex. + If found, return True, indicating a negative cycle. + """ + 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( - graph: list[dict[str, int]], vertex_count: int, edge_count: int, src: int -) -> list[float]: +def reconstruct_paths(predecessor: List[int], vertex_count: int, src: int) -> List[List[int]]: """ - Returns shortest paths from a vertex src to all - other vertices. - >>> edges = [(2, 1, -10), (3, 2, 3), (0, 3, 5), (0, 1, 4)] - >>> g = [{"src": s, "dst": d, "weight": w} for s, d, w in edges] - >>> bellman_ford(g, 4, 4, 0) - [0.0, -2.0, 8.0, 5.0] - >>> g = [{"src": s, "dst": d, "weight": w} for s, d, w in edges + [(1, 3, 5)]] - >>> bellman_ford(g, 4, 5, 0) - Traceback (most recent call last): - ... - Exception: Negative cycle found + Reconstructs the shortest paths from the source vertex to each vertex using the predecessor list. + """ + paths = [[] for _ in range(vertex_count)] + for vertex in range(vertex_count): + if predecessor[vertex] == -1: + paths[vertex] = ["Negative cycle detected"] + elif predecessor[vertex] is not None: + path = [] + current = vertex + while current is not None: + 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): - u, v, w = (graph[j][k] for k in ["src", "dst", "weight"]) + for edge in graph: + 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]: - distance[v] = distance[u] + w - - negative_cycle_exists = check_negative_cycle(graph, distance, edge_count) - if negative_cycle_exists: + # Step 2: Check for negative weight cycles + if check_negative_cycle(graph, distance, predecessor): 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() - V = int(input("Enter number of vertices: ").strip()) - E = int(input("Enter number of edges: ").strip()) + 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) - src, dest, weight = ( - int(x) - for x in input("Enter source, destination, weight: ").strip().split(" ") - ) - graph[i] = {"src": src, "dst": dest, "weight": weight} + for i in range(E): + print(f"Edge {i + 1}") + src, dest, weight = map(int, input("Enter source, destination, weight: ").strip().split()) + if src < 0 or src >= V or dest < 0 or dest >= V: + print(f"Invalid vertices: src and dest should be between 0 and {V - 1}") + continue + graph.append(Edge(src, dest, weight)) - source = int(input("\nEnter shortest path source:").strip()) - shortest_distance = bellman_ford(graph, V, E, source) - print_distance(shortest_distance, 0) + source = int(input("\nEnter shortest path source vertex: ").strip()) + if source < 0 or source >= V: + 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) From 40e312af1b6197a9f775b880ff19a9caeb0399d7 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Thu, 10 Oct 2024 22:19:44 +0000 Subject: [PATCH 2/2] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- graphs/bellman_ford.py | 31 ++++++++++++++++++++++++------- 1 file changed, 24 insertions(+), 7 deletions(-) diff --git a/graphs/bellman_ford.py b/graphs/bellman_ford.py index f69572d90..79985c1bc 100644 --- a/graphs/bellman_ford.py +++ b/graphs/bellman_ford.py @@ -14,20 +14,29 @@ def print_distance_and_paths(distance: List[float], paths: List[List[int]], src: print(f"{vertex}\t\t{dist}\t\t\t\t{path_str}") -def check_negative_cycle(graph: List[Edge], distance: List[float], predecessor: List[int]) -> bool: +def check_negative_cycle( + graph: List[Edge], distance: List[float], predecessor: List[int] +) -> bool: """ Checks if there is a negative weight cycle reachable from the source vertex. If found, return True, indicating a negative cycle. """ for edge in graph: - if distance[edge.src] != float("inf") and distance[edge.src] + edge.weight < distance[edge.dst]: + 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 + predecessor[ + edge.dst + ] = -1 # Use -1 as a marker for negative cycle detection return True return False -def reconstruct_paths(predecessor: List[int], vertex_count: int, src: int) -> List[List[int]]: +def reconstruct_paths( + predecessor: List[int], vertex_count: int, src: int +) -> List[List[int]]: """ Reconstructs the shortest paths from the source vertex to each vertex using the predecessor list. """ @@ -47,7 +56,9 @@ def reconstruct_paths(predecessor: List[int], vertex_count: int, src: int) -> Li return paths -def bellman_ford(graph: List[Edge], vertex_count: int, src: int) -> Tuple[List[float], List[List[int]]]: +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. """ @@ -58,7 +69,10 @@ def bellman_ford(graph: List[Edge], vertex_count: int, src: int) -> Tuple[List[f # Step 1: Relax edges repeatedly for _ in range(vertex_count - 1): for edge in graph: - if distance[edge.src] != float("inf") and distance[edge.src] + edge.weight < distance[edge.dst]: + 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 @@ -75,6 +89,7 @@ def bellman_ford(graph: List[Edge], vertex_count: int, src: int) -> Tuple[List[f if __name__ == "__main__": # Example graph input for testing purposes import doctest + doctest.testmod() try: @@ -85,7 +100,9 @@ if __name__ == "__main__": for i in range(E): print(f"Edge {i + 1}") - src, dest, weight = map(int, input("Enter source, destination, weight: ").strip().split()) + src, dest, weight = map( + int, input("Enter source, destination, weight: ").strip().split() + ) if src < 0 or src >= V or dest < 0 or dest >= V: print(f"Invalid vertices: src and dest should be between 0 and {V - 1}") continue