made error resulution changes(removing white spaces)

Author: nagajaideep

pydatastructs/graphs/algorithms.py

@@ -11,6 +11,7 @@
 from pydatastructs.graphs.graph import Graph
 from pydatastructs.linear_data_structures.algorithms import merge_sort_parallel
 from pydatastructs import PriorityQueue
+from pydatastructs.graphs.graph import AdjacencyListGraphNode
 
 __all__ = [
     'breadth_first_search',
@@ -24,6 +25,7 @@
     'topological_sort',
     'topological_sort_parallel',
     'max_flow'
+    'a_star_with_manhattan'
 ]
 
 Stack = Queue = deque
@@ -700,6 +702,7 @@ def shortest_paths(graph: Graph, algorithm: str,
         'bellman_ford' -> Bellman-Ford algorithm as given in [1].
 
         'dijkstra' -> Dijkstra algorithm as given in [2].
+        'a_star_with_manhattan' -> A* algorithm with Manhattan distance
     source: str
         The name of the source the node.
     target: str
@@ -745,10 +748,18 @@ def shortest_paths(graph: Graph, algorithm: str,
 
     .. [1] https://en.wikipedia.org/wiki/Bellman%E2%80%93Ford_algorithm
     .. [2] https://en.wikipedia.org/wiki/Dijkstra%27s_algorithm
+    .. [3] https://en.wikipedia.org/wiki/A*_search_algorithm
     """
     raise_if_backend_is_not_python(
         shortest_paths, kwargs.get('backend', Backend.PYTHON))
     import pydatastructs.graphs.algorithms as algorithms
+    if algorithm == 'a_star_with_manhattan':
+        # A* with this implementation requires both source and target
+        if not target:
+            raise ValueError("Target must be specified for A* algorithm")
+        
+        func = "_a_star_with_manhattan_" + graph._impl
+        return getattr(algorithms, func)(graph, source, target)
     func = "_" + algorithm + "_" + graph._impl
     if not hasattr(algorithms, func):
         raise NotImplementedError(
@@ -825,50 +836,36 @@ def manhattan_distance(node1: str, node2: str) -> float:
             return abs(x1 - x2) + abs(y1 - y2)
         except (ValueError, TypeError):
             raise ValueError(f"Invalid node format. Expected 'x,y', got {node1} or {node2}")
-
     # Validate inputs
     if start == target:
         return 0, {start: None}
-
     if start not in graph.vertices or target not in graph.vertices:
         raise ValueError(f"Start or target node not in graph. Start: {start}, Target: {target}")
-
-    # Initialize data structures
     g_score = {v: float('inf') for v in graph.vertices}
     f_score = {v: float('inf') for v in graph.vertices}
     pred = {v: None for v in graph.vertices}
     visited = {v: False for v in graph.vertices}
-
-    # Initialize start node
     g_score[start] = 0
     f_score[start] = manhattan_distance(start, target)
-
-    # Priority queue for A* algorithm
     pq = PriorityQueue(implementation='binomial_heap')
     pq.push(start, f_score[start])
-
     while not pq.is_empty:
         current = pq.pop()
-
-        # Goal reached
         if current == target:
-            return g_score[target], pred
-
+            path_pred = {}
+            node = target
+            while node is not None:
+                path_pred[node] = pred[node]
+                node = pred[node]
+            return g_score[target], path_pred
         visited[current] = True
-
-        # Explore neighbors
         for neighbor in graph.neighbors(current):
             if visited[neighbor.name]:
                 continue
-
             edge = graph.get_edge(current, neighbor.name)
             if not edge:
                 continue
-
-            # Calculate tentative g_score
             tentative_g_score = g_score[current] + edge.value
-            
-            # Update if better path found
             if tentative_g_score < g_score[neighbor.name]:
                 pred[neighbor.name] = current
                 g_score[neighbor.name] = tentative_g_score
@@ -877,12 +874,8 @@ def manhattan_distance(node1: str, node2: str) -> float:
                     manhattan_distance(neighbor.name, target)
                 )
                 pq.push(neighbor.name, f_score[neighbor.name])
-
-    # No path exists
     raise ValueError(f"No path exists between {start} and {target}")
-
 _a_star_with_manhattan_adjacency_matrix = _a_star_with_manhattan_adjacency_list
-
 def all_pair_shortest_paths(graph: Graph, algorithm: str,
                             **kwargs) -> tuple:
     """

pydatastructs/graphs/tests/test_algorithms.py

@@ -4,7 +4,6 @@
 depth_first_search, shortest_paths, topological_sort,
 topological_sort_parallel, max_flow)
 from pydatastructs.utils.raises_util import raises
-
 def test_breadth_first_search():
 
     def _test_breadth_first_search(ds):
@@ -293,7 +292,6 @@ def _test_shortest_paths_positive_edges(ds, algorithm):
         graph.remove_edge('SLC', 'D')
         graph.add_edge('D', 'SLC', -10)
         assert raises(ValueError, lambda: shortest_paths(graph, 'bellman_ford', 'SLC'))
-    
     def _test_a_star_manhattan(ds):
         import pydatastructs.utils.misc_util as utils
         GraphNode = getattr(utils, "Adjacency" + ds + "GraphNode")
@@ -305,7 +303,6 @@ def _test_a_star_manhattan(ds):
         graph = Graph(*vertices)
         graph.add_edge("0,0", "1,1", 2)
         graph.add_edge("1,1", "2,2", 3)
-        
         distance, pred = shortest_paths(graph, 'a_star_with_manhattan', "0,0", "2,2")
         assert distance == 5  # 2 + 3
         assert pred['2,2'] == '1,1'
@@ -316,13 +313,11 @@ def _test_a_star_manhattan(ds):
             GraphNode("1,1"),
             GraphNode("2,2")
         )
-        
         with raises(ValueError, match="No path exists"):
             shortest_paths(no_path_graph, 'a_star_with_manhattan', "0,0", "2,2")
         # Same node scenario
         same_node_graph = Graph(GraphNode("1,1"))
         distance, pred = shortest_paths(same_node_graph, 'a_star_with_manhattan', "1,1", "1,1")
-        
         assert distance == 0
         assert pred == {'1,1': None}
     def _test_shortest_paths_negative_edges(ds, algorithm):