#299: implement Bellman-Ford Algo part 1

Author: Hamid Gasmi

10-algo-ds-implementations/graph_fastest_path_bellman_ford.py

@@ -37,8 +37,24 @@
 
 
 class Bellman_Ford(Fastest_Path_Base):
-    
+
     def __compute_fastest_path (self):
-        pass
+        # Initializations
+        self.__parent = [ -1 for _ in range(self.__graph.vertices_count) ]
+        self.__distance = [ self.__max_distance for _ in range(self.__graph.vertices_count) ]
+
+        self.__distance[ self.__path_source_node ] = 0
+
+        for n in range(self.__graph.vertices_count):
+            for v in range(self.__graph.vertices_count):
+                if self.__distance[v] != self.__max_distance:
+                    for edge in self.__graph.adjacency_list[v]:
+                        candidate_distance = self.__distance[v] + edge.weight
+                        if self.__distance[edge.sink] > candidate_distance:
+                            self.__distance[edge.sink] = candidate_distance
+                            parents[edge.sink] = v
+                            reachable[edge.sink] = 1
+                            if n == self.__graph.vertices_count - 1:
+                                q.put(a_tuple.vertex) 
 
 

10-algo-ds-implementations/graph_fastest_path_dijkstra_array.py

@@ -1,6 +1,3 @@
-from typing import List
-from graph import Graph_Adjacency_List
-
 '''
     Dijkstra's Algorithm
     Input: Weighted Graph: G(V, E, W), s ∈ V
@@ -17,11 +14,11 @@
             - Dense graph (|E| = O(|V|^2)) --> T = O(|V|^2 + |V|^2) = O(|V|^2)
             - Sparce graph (|E| ~ |V|)     --> T = O(|V|^2 + |V|) = O(|V|^2) 
         - Space Complexity: O(|V|)
-            - S(Parent list) + S(distance list) + S(visited nodes set) = O(|V| + |V| + |V|) = O(|V|)
-    
+            - S(Parent list) + S(distance list) + S(visited nodes set) = O(|V| + |V| + |V|) = O(|V|)   
 '''
 
-Candidate = namedtuple('Candidate', ['distance', 'node'])
+from typing import List
+from graph import Graph_Adjacency_List
 
 class Dijkstra_Heap_Queue:
     def __init__(self, graph: Graph_Adjacency_List, s: int):
@@ -61,7 +58,8 @@ def __get_closest_node(self, visited_nodes: set) -> int:
                 min_distance = self.__distance[candidate]
 
         return closest_node
-
+    
+    # O(|V|^2)
     def __compute_fastest_path (self):
         # Initialization
         self.__parent = [ -1 for _ in range(self.__graph.vertices_count) ]                       # O(|V|)
@@ -84,5 +82,4 @@ def __compute_fastest_path (self):
                     self.__distance[ adjacent ] = candidate_distance
 
             closest_node = self.__get_closest_node(visted_nodes)   # O(|V|)
-
-        
+