Add dinic's max flow algorithm (#534)

Author: sak-codes

pydatastructs/graphs/adjacency_list.py

@@ -35,6 +35,12 @@ def is_adjacent(self, node1, node2):
         node1 = self.__getattribute__(node1)
         return hasattr(node1, node2)
 
+    def num_vertices(self):
+        return len(self.vertices)
+
+    def num_edges(self):
+        return sum(len(self.neighbors(v)) for v in self.vertices)
+
     def neighbors(self, node):
         node = self.__getattribute__(node)
         return [self.__getattribute__(name) for name in node.adjacent]

pydatastructs/graphs/adjacency_matrix.py

@@ -40,6 +40,12 @@ def is_adjacent(self, node1, node2):
         row = self.matrix.get(node1, {})
         return row.get(node2, False) is not False
 
+    def num_vertices(self):
+        return len(self.vertices)
+
+    def num_edges(self):
+        return sum(len(v) for v in self.matrix.values())
+
     def neighbors(self, node):
         node = str(node)
         neighbors = []

pydatastructs/graphs/algorithms.py

@@ -1067,10 +1067,9 @@ def _job(graph: Graph, u: str):
     return L
 
 
-def _breadth_first_search_max_flow(graph: Graph, source_node, sink_node, flow_passed):
+def _breadth_first_search_max_flow(graph: Graph, source_node, sink_node, flow_passed, for_dinic=False):
     bfs_queue = Queue()
     parent, currentPathC = {}, {}
-    parent[source_node] = -2
     currentPathC[source_node] = float('inf')
     bfs_queue.append(source_node)
     while len(bfs_queue) != 0:
@@ -1080,11 +1079,11 @@ def _breadth_first_search_max_flow(graph: Graph, source_node, sink_node, flow_pa
             for next_node in next_nodes:
                 capacity = graph.get_edge(curr_node, next_node.name).value
                 fp = flow_passed.get((curr_node, next_node.name), 0)
-                if capacity and parent.get(next_node.name, False) is False and capacity - fp> 0:
+                if capacity and parent.get(next_node.name, False) is False and capacity - fp > 0:
                     parent[next_node.name] = curr_node
                     next_flow = min(currentPathC[curr_node], capacity - fp)
                     currentPathC[next_node.name] = next_flow
-                    if next_node.name == sink_node:
+                    if next_node.name == sink_node and not for_dinic:
                         return (next_flow, parent)
                     bfs_queue.append(next_node.name)
     return (0, parent)
@@ -1107,6 +1106,51 @@ def _max_flow_edmonds_karp_(graph: Graph, source, sink):
         new_flow, parent = _breadth_first_search_max_flow(graph, source, sink, flow_passed)
     return m_flow
 
+
+def _depth_first_search_max_flow_dinic(graph: Graph, u, parent, sink_node, flow, flow_passed):
+    if u == sink_node:
+        return flow
+
+    next_nodes = graph.neighbors(u)
+    if len(next_nodes) != 0:
+        for next_node in next_nodes:
+            capacity = graph.get_edge(u, next_node.name).value
+            fp = flow_passed.get((u, next_node.name), 0)
+            parent_cond = parent.get(next_node.name, None)
+            if parent_cond and parent_cond == u and capacity - fp > 0:
+                path_flow = _depth_first_search_max_flow_dinic(graph,
+                                                               next_node.name,
+                                                               parent, sink_node,
+                                min(flow, capacity - fp), flow_passed)
+                if path_flow > 0:
+                    fp = flow_passed.get((u, next_node.name), 0)
+                    flow_passed[(u, next_node.name)] = fp + path_flow
+                    fp = flow_passed.get((next_node.name, u), 0)
+                    flow_passed[(next_node.name, u)] = fp - path_flow
+                    return path_flow
+    return 0
+
+
+def _max_flow_dinic_(graph: Graph, source, sink):
+    max_flow = 0
+    flow_passed = {}
+    while True:
+        next_flow, parent = _breadth_first_search_max_flow(graph, source, sink, flow_passed, True)
+        if parent.get(sink, False) is False:
+            break
+
+        while True:
+            path_flow = _depth_first_search_max_flow_dinic(graph, source,
+                                                           parent, sink,
+                                                           float('inf'),
+                                                           flow_passed)
+            if path_flow <= 0:
+                break
+            max_flow += path_flow
+
+    return max_flow
+
+
 def max_flow(graph, source, sink, algorithm='edmonds_karp', **kwargs):
     raise_if_backend_is_not_python(
         max_flow, kwargs.get('backend', Backend.PYTHON))

pydatastructs/graphs/graph.py

@@ -147,3 +147,17 @@ def remove_edge(self, source, target):
         """
         raise NotImplementedError(
             "This is an abstract method.")
+
+    def num_vertices(self):
+        """
+        Number of vertices
+        """
+        raise NotImplementedError(
+            "This is an abstract method.")
+
+    def num_edges(self):
+        """
+        Number of edges
+        """
+        raise NotImplementedError(
+            "This is an abstract method.")

pydatastructs/graphs/tests/test_algorithms.py

@@ -17,6 +17,8 @@ def _test_breadth_first_search(ds):
 
         G1 = Graph(V1, V2, V3)
 
+        assert G1.num_vertices() == 3
+
         edges = [
             (V1.name, V2.name),
             (V2.name, V3.name),
@@ -26,6 +28,8 @@ def _test_breadth_first_search(ds):
         for edge in edges:
             G1.add_edge(*edge)
 
+        assert G1.num_edges() == len(edges)
+
         parent = {}
         def bfs_tree(curr_node, next_node, parent):
             if next_node != "":
@@ -55,6 +59,8 @@ def bfs_tree(curr_node, next_node, parent):
         for edge in edges:
             G2.add_edge(*edge)
 
+        assert G2.num_edges() == len(edges)
+
         path = []
         def path_finder(curr_node, next_node, dest_node, parent, path):
             if next_node != "":
@@ -436,3 +442,5 @@ def _test_max_flow(ds, algorithm):
 
     _test_max_flow("List", "edmonds_karp")
     _test_max_flow("Matrix", "edmonds_karp")
+    _test_max_flow("List", "dinic")
+    _test_max_flow("Matrix", "dinic")