johnson's algorithm and fixed tests for all pair shortes

t paths

Author: Prerak Singh

pydatastructs/graphs/algorithms.py

@@ -5,7 +5,7 @@
 from collections import deque
 from concurrent.futures import ThreadPoolExecutor
 from pydatastructs.utils.misc_util import (
-    _comp, raise_if_backend_is_not_python, Backend)
+    _comp, raise_if_backend_is_not_python, Backend, AdjacencyListGraphNode)
 from pydatastructs.miscellaneous_data_structures import (
     DisjointSetForest, PriorityQueue)
 from pydatastructs.graphs.graph import Graph
@@ -799,7 +799,7 @@ def _dijkstra_adjacency_list(graph: Graph, start: str, target: str):
         visited[u] = True
         for v in graph.vertices:
             edge_str = u + '_' + v
-            if (edge_str in graph.edge_weights and graph.edge_weights[edge_str].value > 0 and
+            if (edge_str in graph.edge_weights and graph.edge_weights[edge_str].value >= 0 and
                 visited[v] is False and dist[v] > dist[u] + graph.edge_weights[edge_str].value):
                 dist[v] = dist[u] + graph.edge_weights[edge_str].value
                 pred[v] = u
@@ -900,6 +900,53 @@ def _floyd_warshall_adjacency_list(graph: Graph):
 
 _floyd_warshall_adjacency_matrix = _floyd_warshall_adjacency_list
 
+def _johnson_adjacency_list(graph: Graph):
+    new_vertex=AdjacencyListGraphNode('q')
+    graph.add_vertex(new_vertex)
+
+    for vertex in graph.vertices:
+        if vertex != 'q':
+            graph.add_edge('q',vertex,0)
+
+    distances, predecessors=shortest_paths(graph,'bellman_ford','q')
+
+    edges_to_remove=[]
+    for edge in graph.edge_weights:
+        edge_node=graph.edge_weights[edge]
+        if edge_node.source.name=='q':
+            edges_to_remove.append((edge_node.source.name,edge_node.target.name))
+
+    for u,v in edges_to_remove:
+        graph.remove_edge(u,v)
+    graph.remove_vertex('q')
+
+    for edge in graph.edge_weights:
+        edge_node=graph.edge_weights[edge]
+        u,v=edge_node.source.name,edge_node.target.name
+        graph.edge_weights[edge].value+=distances[u]-distances[v]
+
+    print(graph.edge_weights)
+    all_distances={}
+    all_next_vertex={}
+
+    for vertex in graph.vertices:
+        u = vertex
+        dijkstra_dist,dijkstra_pred=shortest_paths(graph, 'dijkstra', u)
+        print(dijkstra_pred)
+        all_distances[u]={}
+        all_next_vertex[u] = {}
+        for v in graph.vertices:
+            if dijkstra_pred[v]==None or dijkstra_pred[v]==u :
+                all_next_vertex[u][v]=u
+            else:
+                all_next_vertex[u][v]=None
+            if v in dijkstra_dist:
+                all_distances[u][v]=dijkstra_dist[v]-distances[u]+distances[v]
+            else:
+                all_distances[u][v]=float('inf')
+
+    return (all_distances,all_next_vertex)
+
 def topological_sort(graph: Graph, algorithm: str,
                      **kwargs) -> list:
     """

pydatastructs/graphs/tests/test_algorithms.py

@@ -1,7 +1,7 @@
 from pydatastructs import (breadth_first_search, Graph,
 breadth_first_search_parallel, minimum_spanning_tree,
 minimum_spanning_tree_parallel, strongly_connected_components,
-depth_first_search, shortest_paths, topological_sort,
+depth_first_search, shortest_paths,all_pair_shortest_paths, topological_sort,
 topological_sort_parallel, max_flow)
 from pydatastructs.utils.raises_util import raises
 
@@ -336,7 +336,7 @@ def _test_shortest_paths_negative_edges(ds, algorithm):
         graph.add_edge('2', '3', 3)
         graph.add_edge('3', '4', 2)
         graph.add_edge('4', '2', -1)
-        dist, next_v = shortest_paths(graph, algorithm, 's')
+        dist, next_v = all_pair_shortest_paths(graph, algorithm)
         assert dist == {'1': {'3': -2, '1': 0, '4': 0, '2': -1},
                         '2': {'1': 4, '3': 2, '2': 0, '4': 4},
                         '3': {'4': 2, '3': 0, '1': 5, '2': 1},
@@ -346,6 +346,10 @@ def _test_shortest_paths_negative_edges(ds, algorithm):
                           '3': {'4': '3', '3': '3', '1': None, '2': None},
                           '4': {'2': '4', '4': '4', '1': None, '3': None}}
 
+    _test_shortest_paths_negative_edges("List",'floyd_warshall')
+    _test_shortest_paths_negative_edges("Matrix",'floyd_warshall')
+    _test_shortest_paths_negative_edges("List",'johnson')
+
 def test_topological_sort():
 
     def _test_topological_sort(func, ds, algorithm, threads=None):