Merge branch 'main' into node-ids

Author: prex03

pydatastructs/graphs/_backend/cpp/Algorithms.hpp

@@ -319,7 +319,6 @@ static PyObject* minimum_spanning_tree_prim_adjacency_list(PyObject* self, PyObj
     return reinterpret_cast<PyObject*>(mst);
 }
 
-
 static PyObject* shortest_paths_dijkstra_adjacency_list(PyObject* self, PyObject* args, PyObject* kwargs) {
     PyObject* graph_obj;
     const char* source_name;
@@ -374,6 +373,7 @@ static PyObject* shortest_paths_dijkstra_adjacency_list(PyObject* self, PyObject
                 dist[v_id] = new_dist;
                 pred[v_id] = u_id;
                 pq.push({new_dist, v_id});
+
             }
         }
     }
@@ -410,6 +410,7 @@ static PyObject* shortest_paths_dijkstra_adjacency_list(PyObject* self, PyObject
         }
 
         if (PyDict_SetItemString(pred_dict, name.c_str(), py_pred) < 0) {
+
             Py_DECREF(py_pred);
             Py_DECREF(dist_dict);
             Py_DECREF(pred_dict);

pydatastructs/graphs/_backend/cpp/algorithms.cpp

@@ -7,6 +7,7 @@ static PyMethodDef AlgorithmsMethods[] = {
     {"bfs_adjacency_list", (PyCFunction)breadth_first_search_adjacency_list, METH_VARARGS | METH_KEYWORDS, "Run BFS on adjacency list with callback"},
     {"bfs_adjacency_matrix", (PyCFunction)breadth_first_search_adjacency_matrix, METH_VARARGS | METH_KEYWORDS, "Run BFS on adjacency matrix with callback"},
     {"minimum_spanning_tree_prim_adjacency_list", (PyCFunction)minimum_spanning_tree_prim_adjacency_list, METH_VARARGS | METH_KEYWORDS, "Run Prim's algorithm on adjacency list"},
+    {"shortest_paths_dijkstra_adjacency_list", (PyCFunction)shortest_paths_dijkstra_adjacency_list, METH_VARARGS | METH_KEYWORDS, "Dijkstra's algorithm for adjacency list graphs"},
     {NULL, NULL, 0, NULL}
 };
 

pydatastructs/graphs/algorithms.py

@@ -804,15 +804,19 @@ 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
     """
-    raise_if_backend_is_not_python(
-        shortest_paths, kwargs.get('backend', Backend.PYTHON))
-    import pydatastructs.graphs.algorithms as algorithms
-    func = "_" + algorithm + "_" + graph._impl
-    if not hasattr(algorithms, func):
-        raise NotImplementedError(
-        "Currently %s algorithm isn't implemented for "
-        "finding shortest paths in graphs."%(algorithm))
-    return getattr(algorithms, func)(graph, source, target)
+    backend = kwargs.get('backend', Backend.PYTHON)
+    if (backend == Backend.PYTHON):
+        import pydatastructs.graphs.algorithms as algorithms
+        func = "_" + algorithm + "_" + graph._impl
+        if not hasattr(algorithms, func):
+            raise NotImplementedError(
+            "Currently %s algorithm isn't implemented for "
+            "finding shortest paths in graphs."%(algorithm))
+        return getattr(algorithms, func)(graph, source, target)
+    else:
+        from pydatastructs.graphs._backend.cpp._algorithms import shortest_paths_dijkstra_adjacency_list
+        if graph._impl == "adjacency_list" and algorithm == 'dijkstra':
+            return shortest_paths_dijkstra_adjacency_list(graph, source, target)
 
 def _bellman_ford_adjacency_list(graph: Graph, source: str, target: str) -> tuple:
     distances, predecessor, visited, cnts = {}, {}, {}, {}

pydatastructs/graphs/tests/test_algorithms.py

@@ -367,6 +367,25 @@ def _test_shortest_paths_positive_edges(ds, algorithm):
         graph.add_edge('D', 'SLC', -10)
         assert raises(ValueError, lambda: shortest_paths(graph, 'bellman_ford', 'SLC'))
 
+        if (ds == 'List' and algorithm == 'dijkstra'):
+            vertices2 = [AdjacencyListGraphNode('S', 0, backend = Backend.CPP), AdjacencyListGraphNode('C', 0, backend = Backend.CPP),
+                        AdjacencyListGraphNode('SLC', 0, backend = Backend.CPP), AdjacencyListGraphNode('SF', 0, backend = Backend.CPP),
+                        AdjacencyListGraphNode('D', 0, backend = Backend.CPP)]
+            graph2 = Graph(*vertices2, backend = Backend.CPP)
+            graph2.add_edge('S', 'SLC', 2)
+            graph2.add_edge('C', 'S', 4)
+            graph2.add_edge('C', 'D', 2)
+            graph2.add_edge('SLC', 'C', 2)
+            graph2.add_edge('SLC', 'D', 3)
+            graph2.add_edge('SF', 'SLC', 2)
+            graph2.add_edge('SF', 'S', 2)
+            graph2.add_edge('D', 'SF', 3)
+            (dist2, pred2) = shortest_paths(graph2, algorithm, 'SLC', backend = Backend.CPP)
+            assert dist2 == {'S': 6, 'C': 2, 'SLC': 0, 'SF': 6, 'D': 3}
+            assert pred2 == {'S': 'C', 'C': 'SLC', 'SLC': None, 'SF': 'D', 'D': 'SLC'}
+
+
+
     def _test_shortest_paths_negative_edges(ds, algorithm):
         import pydatastructs.utils.misc_util as utils
         GraphNode = getattr(utils, "Adjacency" + ds + "GraphNode")