#299: start Bellman-Form implementation

Author: Hamid Gasmi

10-algo-ds-implementations/graph_fastest_path_base.py

@@ -0,0 +1,46 @@
+from typing import List
+from graph import Graph_Adjacency_List
+
+'''
+    Fastest Path base
+    
+    Implementation Assumptions:
+        - Directed graph
+        - Edges number starts from 0 (zero-based numbering)
+        - Edges list is valid
+            - 0 <= edge.source, edge.sink < vertices_count for any edge in edges list
+            - It does not have duplicates
+    
+'''
+
+class Fastest_Path_Base:
+    def __init__(self, graph: Graph_Adjacency_List, s: int):
+        self.__max_distance = 10**7
+        
+        self.__graph = graph
+
+        self.__path_source_node = s
+        self.__parent = []
+        self.__distance = []
+    
+    def fastest_distance_to(self, dest: int) -> int:
+        if len(self.__distance) == 0:
+            self.__compute_fastest_path()
+        
+        return self.__distance[dest]
+
+    def fastest_path_to(self, dest: int) -> List[int]:
+        if len(self.__distance) == 0:
+            self.__compute_fastest_path()
+        
+        v = dest
+        reversed_path = []
+        while v != -1:
+            reversed_path.append(v)
+            v = self.__parent[v]
+        
+        return reversed_path[::-1]
+    
+    # abstract method
+    def __compute_fastest_path (self):
+        pass

10-algo-ds-implementations/graph_fastest_path_bellman_ford.py

@@ -0,0 +1,44 @@
+'''
+    Input: G(V, E, W) a directed graph without a negative cycle, s ∈ V
+        - -Infinity < We < +Infinity for any e in E
+        - G MUST not have a negative cycle => min_dist(u, v) = -Infinity for any { u, v } ⊆ V
+        - G does not have negative cycle => G is Directed graph
+            E.g. 
+                G(V, E, W) an undirected graph with 2 vertices and 1 edge with weight is negative
+                min_distance(1, 2) = - Infinity
+                    -1
+                1 ------- 2
+
+    Output:
+        - fastest path from s to any v in V
+        - fastest path distances from s to any v in V
+
+    Question: Why Dijskra's algorithm doesn't work in this case?
+           -2
+        3 ---- > 4      Dijkstra(1, 4) = 2
+        ^        ^      Bellman-Ford(1, 4) = 1
+       3|        | 1
+        1 -----> 2
+            1
+    
+    Time & Space Complexity:
+        - Time Complexity:
+        - Space Complexity:
+
+    Implementation Assumptions:
+        - Zero-based numbering: Edges number starts from 0
+        - Edges list is valid
+            - 0 <= edge.source, edge.sink < vertices_count for any edge in edges list
+            - It does not have duplicates
+            - It doesn't have a negative cycle
+
+'''
+from graph_fastest_path_base import Fastest_Path_Base
+
+
+class Bellman_Ford(Fastest_Path_Base):
+    
+    def __compute_fastest_path (self):
+        pass
+    
+