2 more tree/graph problems

Author: StBogdan

chapter_4/p4_1.py

@@ -0,0 +1,63 @@
+from typing import List
+from utils.graphs import Ditex
+from collections import deque
+
+
+def populate_graph(edges: List[tuple]) -> dict:
+    graph = {}
+    for a, b in edges:
+        if a not in graph:
+            graph[a] = Ditex(a)
+        if b not in graph:
+            graph[b] = Ditex(b)
+
+        graph[a].out_edges.add(b)
+        graph[b].in_edges.add(a)
+    return graph
+
+
+def route_digraph(edges: List[tuple], s: int, e: int):
+    graph = populate_graph(edges)
+    start_dq = deque()
+    end_dq = deque()
+
+    seen_start = set([s])
+    seen_end = set([e])
+
+    start_dq.append(s)
+    end_dq.append(e)
+
+    round_robin_flag = True
+
+    while start_dq and end_dq:
+        if round_robin_flag:  # From start to end
+            ce = graph[start_dq.popleft()]
+            seen_start.add(ce.val)
+
+            if ce.val in seen_end:
+                return True
+            for child in ce.out_edges:
+                if child not in seen_start:
+                    start_dq.append(child)
+        else:  # From end toward start
+            ce = graph[end_dq.popleft()]
+            seen_end.add(ce.val)
+
+            if ce.val in seen_start:
+                return True
+
+            for parent in ce.in_edges:
+                if parent not in seen_end:
+                    end_dq.append(parent)
+
+        round_robin_flag != round_robin_flag
+    return False
+
+
+if __name__ == "__main__":
+    edges = [(1, 11), (1, 12), (1, 14), (12, 23),
+             (23, 2), (2, 21), (2, 22), (24, 2)]
+    targets = (1, 2), (11, 24), (1, 22), (1, 11)
+    for s, e in targets:
+        print(
+            f"Is there a route from {s} to {e} ? {route_digraph(edges, s,e)}")

chapter_4/p4_8.py

@@ -0,0 +1,96 @@
+from utils.graphs import BiNode, ltbt
+from typing import Tuple, Optional
+from utils.treeviz import viz_tree
+
+# No parent, method 1 with covers
+
+
+def first_common_ancestor(r: BiNode, e1: int, e2: int):
+    res_1 = com_anc_covers(r, e1, e2)
+    res_2 = com_anc_helper(r, e1, e2)
+
+    print(f"Common anc, method 1 : {res_1}, "
+          f"method 2: {res_2[0].val if res_2[1] else 'Not found'}")
+    return res_2[0].val if res_2[1] else None
+
+
+def com_anc_covers(n: BiNode,
+                   e1: int,
+                   e2: int) -> Optional[int]:
+    if not n:
+        return None
+
+    # If both are covered by the left/right subtree,
+    # Look for solution there
+    rc1 = covers(n.right, e1)
+    rc2 = covers(n.right, e2)
+    if rc1 and rc2:
+        return com_anc_covers(n.right, e1, e2)
+
+    lc1 = covers(n.left, e1)
+    lc2 = covers(n.left, e2)
+    if lc1 and lc2:
+        return com_anc_covers(n.left, e1, e2)
+
+    # If current is one of them, and the other in a subtree
+    if (n.val == e1 and (lc2 or rc2)) or (n.val == e2 and (lc1 or rc1)):
+        return n.val
+
+    # If e1 and e2 covered by different subtrees, this is the place
+    if (rc1 ^ rc2) and (lc1 ^ lc2):
+        return n.val
+
+
+def covers(root: BiNode, elem: int):
+    if not root:
+        return False
+    if root.val == elem:
+        return True
+    else:
+        return covers(root.left, elem) or covers(root.right, elem)
+
+# No parent, method 2
+# Send up the result of current search
+
+
+def com_anc_helper(root: BiNode,
+                   e1: int,
+                   e2: int) -> Tuple[Optional[BiNode], Optional[bool]]:
+    if not root:
+        return (None, None)
+
+    # If the ancestor is in the left (or right)subtree,
+    # return that
+
+    left_res, left_has_anc = com_anc_helper(root.left, e1, e2)
+    if left_res and left_has_anc:
+        return (left_res, left_has_anc)
+
+    right_res, right_has_anc = com_anc_helper(root.right, e1, e2)
+    if right_res and right_has_anc:
+        return (right_res, right_has_anc)
+
+    # If both nodes found in the left and right trees
+    # But not ancestors, this is the ancestor
+    if left_res and right_res:
+        return (root, True)
+    else:
+        if (root.val == e1 or root.val == e2):
+            # Current is one of them and the other in subtrees
+            is_anc = (left_res or right_res)
+            return (root, is_anc)
+        else:
+            # Send up if one of target nodes found
+            return (left_res if left_res else right_res, False)
+
+
+if __name__ == "__main__":
+    ex = [2, 10, 30, 55, 15, None, None, 3, 37, None, 17]
+    root = ltbt(ex)
+    viz_tree(root)
+
+    first_common_ancestor(root, 17, 37)
+    first_common_ancestor(root, 17, 37)
+    first_common_ancestor(root, 55, 3)
+    first_common_ancestor(root, 3, 55)
+    first_common_ancestor(root, 2, 9999)

utils/binutils.py

@@ -1,10 +1,12 @@
 # Binary utilities
 
-def blen(a : int):
-    return len(bin(a)) -2
+def blen(a: int):
+    return len(bin(a)) - 2
+
 
 def ones(number: int):
-    return (0b1 << (number)) -1
+    return (0b1 << (number)) - 1
+
 
 if __name__ == "__main__":
-    print(f"{ones(5):b}")
+    print(f"{ones(5):b}")

utils/graphs.py

@@ -11,7 +11,7 @@ def __str__(self):
         return f"Vertex({self.val}) with edges {len(self.edges)}"
 
 
-class Ditex(Vertex):
+class Ditex(Vertex):  # Directed vertex
 
     def __init__(self, val):
         self.val = val
@@ -27,10 +27,6 @@ def __str__(self):
 
 
 class BiNode:
-    val: int = None
-    left = None
-    right = None
-
     def __str__(self):
         return f"({self.left if self.left else '_' }/{self.val}\\{self.right if self.right else '_'})"
 
@@ -41,7 +37,10 @@ def __init__(self, val, left=None, right=None):
 
 
 class BiPaNode(BiNode):
-    parent = None
+
+    def __init__(self, val, left=None, right=None):
+        super().__init__(val, left=left, right=right)
+        self.parent = None
 
 
 def ltbt(arr: List[int]) -> BiNode: