LeetCode 236. Lowest Common Ancestor of a Binary Tree

Author: raul-sauco

README.md

@@ -67,7 +67,8 @@ Proposed solutions to some LeetCode problems. The first column links to the prob
 | [215. Kth Largest Element in an Array][lc215]                           | 🟠 Medium  | [![python](res/py.png)](leetcode/kth-largest-element-in-an-array.py)                |
 | [217. Contains Duplicate][lc217]                                        | 🟢 Easy    | [![python](res/py.png)](leetcode/contains-duplicate.py)                             |
 | [226. Invert Binary Tree][lc226]                                        | 🟢 Easy    | [![python](res/py.png)](leetcode/invert-binary-tree.py)                             |
-| [235. Lowest Common Ancestor of a Binary Search Tree][lc235]            | 🟠 Medium  | [![python](res/py.png)](leetcode/lowest-common-ancestor-of-a-binary-search-tree.py) |
+| [235. Lowest Common Ancestor of a Binary Search Tree][lc235]            | 🟠 Medium  | [![python](res/py.png)][lc235py]                                                    |
+| [236. Lowest Common Ancestor of a Binary Tree][lc236]                   | 🟠 Medium  | [![python](res/py.png)][lc236py]                                                    |
 | [238. Product of Array Except Self][lc238]                              | 🟠 Medium  | [![python](res/py.png)][lc238py]                                                    |
 | [240. Search a 2D Matrix II][lc240]                                     | 🟠 Medium  | [![python](res/py.png)][lc240py]                                                    |
 | [242. Valid Anagram][lc242]                                             | 🟢 Easy    | [![python](res/py.png)](leetcode/valid-anagram.py)                                  |
@@ -218,6 +219,9 @@ Proposed solutions to some LeetCode problems. The first column links to the prob
 [lc217]: https://leetcode.com/problems/contains-duplicate/
 [lc226]: https://leetcode.com/problems/invert-binary-tree/
 [lc235]: https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-search-tree/
+[lc235py]: leetcode/lowest-common-ancestor-of-a-binary-search-tree.py
+[lc236]: https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-tree/
+[lc236py]: leetcode/lowest-common-ancestor-of-a-binary-tree.py
 [lc238]: https://leetcode.com/problems/product-of-array-except-self/
 [lc238py]: leetcode/product-of-array-except-self.py
 [lc240]: https://leetcode.com/problems/search-a-2d-matrix-ii/
@@ -253,7 +257,7 @@ Proposed solutions to some LeetCode problems. The first column links to the prob
 [lc560]: https://leetcode.com/problems/subarray-sum-equals-k/
 [lc560py]: leetcode/subarray-sum-equals-k.py
 [lc567]: https://leetcode.com/problems/permutation-in-string/
-[lc567py]: leetcode/problems/permutation-in-string.py
+[lc567py]: leetcode/permutation-in-string.py
 [lc572]: https://leetcode.com/problems/subtree-of-another-tree/
 [lc576]: https://leetcode.com/problems/out-of-boundary-paths/
 [lc576py]: leetcode/out-of-boundary-paths.py

leetcode/lowest-common-ancestor-of-a-binary-tree.py

@@ -0,0 +1,79 @@
+# 236. Lowest Common Ancestor of a Binary Tree
+# 🟠 Medium
+#
+# https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-tree/
+#
+# Tags: Tree - Depth-First Search - Binary Tree
+
+import timeit
+
+from data import TreeNode, deserializeStringArrayToBinaryTree, drawTree
+
+
+# Explore the tree using DFS, for each branch, return the number of nodes found in that branch, then check the root.
+# When we find 2 matches, p and q, return the root of the subtree we are currently exploring.
+#
+# Time complexity: O(n) - We may need to visit every node.
+# Space complexity: O(n) - The recursive call stack grows linearly with the size of the tree.
+#
+# Runtime: 96 ms, faster than 66.38% of Python3 online submissions for Lowest Common Ancestor of a Binary Tree.
+# Memory Usage: 26.3 MB, less than 30.85% of Python3 online submissions for Lowest Common Ancestor of a Binary Tree.
+class DFSMatchCount:
+    def lowestCommonAncestor(self, root: TreeNode, p: TreeNode, q: TreeNode) -> TreeNode:
+
+        # Define a recursive function that returns the number of p and q found in a subtree.
+        def dfs(node: TreeNode) -> int:
+            # Base case when dfs gets called with None as a parameter.
+            if not node:
+                return 0
+
+            # Recursive call with check to see if we already have a result.
+            # If we already found the LCA, return it up the call chain.
+            left = dfs(node.left)
+            if isinstance(left, TreeNode):
+                return left
+            right = dfs(node.right)
+            if isinstance(right, TreeNode):
+                return right
+
+            # If the sum of the matches in each branch plus matching this node's value is 2, we have found the LCA.
+            found = left + right + int(node.val in [p.val, q.val])
+            if found == 2:
+                return node
+            return found
+
+        return dfs(root)
+
+
+# TODO add an iterative solution.
+
+
+def test():
+    root1 = deserializeStringArrayToBinaryTree("[3,5,1,6,2,0,8,null,null,7,4]")
+    root2 = deserializeStringArrayToBinaryTree("[3,5,1,6,2,0,8,null,null,7,4]")
+    root3 = deserializeStringArrayToBinaryTree("[1,2]")
+    executors = [DFSMatchCount]
+    tests = [
+        [root1, root1.left, root1.right, root1],
+        [root2, root2.left, root2.left.right.right, root2.left],
+        [root3, root3, root3.left, root3],
+    ]
+    for executor in executors:
+        start = timeit.default_timer()
+        for _ in range(int(float("1"))):
+            for col, t in enumerate(tests):
+                sol = executor()
+                result = sol.lowestCommonAncestor(t[0], t[1], t[2])
+                exp = t[3]
+                assert (
+                    result == exp
+                ), f"\033[93m» {result} <> {exp}\033[91m for test {col} using \033[1m{executor.__name__}"
+        stop = timeit.default_timer()
+        used = str(round(stop - start, 5))
+        res = "{0:20}{1:10}{2:10}".format(executor.__name__, used, "seconds")
+        print(f"\033[92m» {res}\033[0m")
+
+
+test()
+
+# drawTree(deserializeStringArrayToBinaryTree("[1,2]"))