update

Author: tiationg-kho

[A]tree/[A]tree-dfs-postorder/865-smallest-subtree-with-all-the-deepest-nodes.py

@@ -6,22 +6,22 @@
 #         self.right = right
 class Solution:
     def subtreeWithAllDeepest(self, root: TreeNode) -> TreeNode:
-        
+
         def dfs(node):
             if not node:
-                return (0, None)
-            left_height, left_cand = dfs(node.left)
-            right_height, right_cand = dfs(node.right)
-            cur_height = max(left_height + 1, right_height + 1)
-            if left_height == right_height:
+                return None, 0
+            left_cand, left_depth = dfs(node.left)
+            right_cand, right_depth = dfs(node.right)
+            cur_cand, cur_depth = None, max(left_depth + 1, right_depth + 1)
+            if left_depth == right_depth:
                 cur_cand = node
-            elif left_height > right_height:
+            elif left_depth > right_depth:
                 cur_cand = left_cand
             else:
                 cur_cand = right_cand
-            return (cur_height, cur_cand)
+            return cur_cand, cur_depth
 
-        return dfs(root)[1]
+        return dfs(root)[0]
 
 # time O(n)
 # space O(n)

[A]tree/[A]tree-dfs-preorder/1457-pseudo-palindromic-paths-in-a-binary-tree.py

@@ -5,60 +5,30 @@
 #         self.left = left
 #         self.right = right
 class Solution:
-    def pseudoPalindromicPaths (self, root: Optional[TreeNode]) -> int:
-        
+    def pseudoPalindromicPaths(self, root: Optional[TreeNode]) -> int:
         res = 0
 
-        def helper(node, freq):
+        def valid(val):
+            count = 0
+            for i in range(1, 10):
+                if val & (1 << i) != 0:
+                    count += 1
+            return count <= 1
+
+        def dfs(node, val):
             nonlocal res
             if not node:
                 return
-                
-            freq[node.val - 1] += 1
-
+            val ^= 1 << node.val
             if not node.left and not node.right:
-                count = 0
-                for i in range(9):
-                    if freq[i] % 2:
-                        count += 1
-                if count <= 1:
-                    res += 1
+                res += valid(val)
                 return
+            dfs(node.left, val)
+            dfs(node.right, val)
 
-            helper(node.left, freq[:])
-            helper(node.right, freq[:])
-        
-        helper(root, [0 for _ in range(9)])
+        dfs(root, 0)
         return res
 
-# time O(n)
-# space O(n)
-# using tree and dfs (preorder and recursive)
-
-class Solution:
-    def pseudoPalindromicPaths (self, root: Optional[TreeNode]) -> int:
-        
-        res = 0
-
-        def helper(node, mask):
-            nonlocal res
-            if not node:
-                return
-
-            mask = mask ^ (1 << node.val)
-            if not node.left and not node.right:
-                count = 0
-                for i in range(1, 10):
-                    if mask & (1 << i):
-                        count += 1
-                if count <= 1:
-                    res += 1
-            helper(node.left, mask)
-            helper(node.right, mask)
-
-        helper(root, 0)
-        return res
-    
 # time O(n)
 # space O(n)
 # using tree and dfs (preorder and recursive) and bitmask 

[A]tree/[A]tree-divide-and-conquer/1008-construct-binary-search-tree-from-preorder-traversal.py

@@ -6,24 +6,21 @@
 #         self.right = right
 class Solution:
     def bstFromPreorder(self, preorder: List[int]) -> Optional[TreeNode]:
-        
-        n = len(preorder)
         idx = 0
 
-        def build_helper(lower, upper):
+        def build(min_val, max_val):
             nonlocal idx
-            if idx >= n:
+            if idx == len(preorder):
                 return None
-            val = preorder[idx]
-            if val <= lower or val >= upper:
+            if preorder[idx] < min_val or preorder[idx] > max_val:
                 return None
-            node = TreeNode(val)
+            node = TreeNode(preorder[idx])
             idx += 1
-            node.left = build_helper(lower, val)
-            node.right = build_helper(val, upper)
+            node.left = build(min_val, node.val)
+            node.right = build(node.val, max_val)
             return node
-
-        return build_helper(float('-inf'), float('inf'))
+        
+        return build(float('-inf'), float('inf'))
 
 # time O(n)
 # space O(n)