Issue 87 (Finding an Exit from a Maze): solved with a Disjoint Set DS: Rank Heuristic and Path Compression Heuristic

Author: Hamid Gasmi

3-graph-algorithms/1_graph_decomposition/reachability-disjoint-sets.py

@@ -0,0 +1,77 @@
+import sys
+from abc import ABC, abstractmethod 
+
+class DisjointSets(ABC):
+    def __init__(self, n, edges):
+        self.parent = [i for i in range(n)]
+        self.rank = [0] * n
+        self.buildDisjointSets(edges)
+    
+    # Time Complexity: O(|E|)
+    # Space Complexity: O(1)
+    def buildDisjointSets(self, edges):
+        for i in range(0, len(edges)):
+            self.union(edges[i][0] - 1, edges[i][1] - 1)
+
+    @abstractmethod
+    def find(self, v):
+        pass
+    
+    # Time Complexity: O(log |V|)
+    # Space Complexity: O(1)
+    def union(self, u, v):
+        ru = self.find(u)
+        rv = self.find(v)
+
+        if ru == rv:
+            return
+
+        if self.rank[ru] >= self.rank[rv]:
+            self.parent[rv] = ru
+
+            if self.rank[ru] == self.rank[rv]:
+                self.rank[ru] += 1
+        else:
+            self.parent[ru] = rv
+
+class MazeDisjointSetRankHeuristic(DisjointSets):
+    # Time Complexity: O(log |V|)
+    # Space Complexity: O(1)
+    def find(self, v):
+        while self.parent[v] != v:
+            v = self.parent[v]
+
+        return v            
+    
+class MazeDisjointSetCompressPathHeuristic(DisjointSets):
+    def find(self, v):
+        if self.parent[v] != v:
+            self.parent[v] = self.find(self.parent[v])
+
+        return self.parent[v]
+
+def reach(edges, n, u, v, solution):
+
+    if solution == 3:
+        # Good job! (Max time used: 0.04/5.00, max memory used: 10145792/536870912.)
+        aMazeSets = MazeDisjointSetRankHeuristic(n, edges)
+        return 1 if aMazeSets.find(u) == aMazeSets.find(v) else 0
+
+    elif solution == 4:
+        # Good job! (Time used: 0.04/5.00, memory used: 9732096/536870912.)
+        aMazeSets = MazeDisjointSetCompressPathHeuristic(n, edges)
+        return 1 if aMazeSets.find(u) == aMazeSets.find(v) else 0
+
+    else:
+        return 0
+
+if __name__ == '__main__':
+    input = sys.stdin.read()
+    data = list(map(int, input.split()))
+    n, m = data[0:2]
+    data = data[2:]
+    edges = list(zip(data[0:(2 * m):2], data[1:(2 * m):2]))
+    x, y = data[2 * m:]
+    x, y = x - 1, y - 1
+    
+    print(reach(edges, n, x, y, 3))

3-graph-algorithms/1_graph_decomposition/reachability_tests/05

@@ -0,0 +1,102 @@
+100 100
+27 96
+6 9
+81 98
+21 94
+22 68
+76 100
+8 50
+38 86
+71 75
+32 93
+16 50
+71 84
+6 72
+22 58
+7 19
+19 76
+44 75
+24 76
+31 35
+11 89
+42 98
+63 92
+37 38
+20 98
+45 91
+23 53
+37 91
+76 93
+67 90
+12 22
+43 52
+23 56
+67 68
+1 21
+17 83
+63 72
+30 32
+7 91
+50 69
+38 44
+55 89
+15 23
+11 72
+28 42
+22 69
+56 79
+5 83
+55 73
+13 72
+7 93
+20 54
+21 55
+66 89
+2 91
+18 88
+26 64
+11 61
+28 59
+12 86
+42 95
+17 82
+50 66
+66 99
+40 71
+20 40
+5 66
+92 95
+32 46
+7 36
+44 94
+6 31
+19 67
+26 57
+53 84
+10 68
+28 74
+34 94
+25 61
+71 88
+10 89
+28 52
+72 79
+39 73
+11 80
+44 79
+13 77
+30 96
+30 53
+10 39
+1 90
+40 91
+62 71
+44 54
+15 17
+69 74
+13 67
+24 69
+34 96
+21 50
+20 91
+42 46

3-graph-algorithms/1_graph_decomposition/reachability_tests/05a

@@ -0,0 +1 @@
+1