17/12/2020

Author: jameszu

Daily-challenge/Dec/16/README.md

@@ -1,66 +1,57 @@
-# Longest Mountain in Array
-Let's call any (contiguous) subarray B (of A) a mountain if the following properties hold:
+# Validate Binary Search Tree
 
-B.length >= 3
-There exists some 0 < i < B.length - 1 such that B[0] < B[1] < ... B[i-1] < B[i] > B[i+1] > ... > B[B.length - 1]
-(Note that B could be any subarray of A, including the entire array A.)
+Solution
+Given the root of a binary tree, determine if it is a valid binary search tree (BST).
 
-Given an array A of integers, return the length of the longest mountain. 
+A valid BST is defined as follows:
 
-Return 0 if there is no mountain.
+The left subtree of a node contains only nodes with keys less than the node's key.
+The right subtree of a node contains only nodes with keys greater than the node's key.
+Both the left and right subtrees must also be binary search trees.
+ 
 
 Example 1:
 
-Input: [2,1,4,7,3,2,5]
-Output: 5
-Explanation: The largest mountain is [1,4,7,3,2] which has length 5.
+
+Input: root = [2,1,3]
+Output: true
 Example 2:
 
-Input: [2,2,2]
-Output: 0
-Explanation: There is no mountain.
-Note:
 
-0 <= A.length <= 10000
-0 <= A[i] <= 10000
-Follow up:
+Input: root = [5,1,4,null,null,3,6]
+Output: false
+Explanation: The root node's value is 5 but its right child's value is 4.
+ 
+
+Constraints:
 
-Can you solve it using only one pass?
-Can you solve it in O(1) space?<br>
+The number of nodes in the tree is in the range [1, 104].
+-231 <= Node.val <= 231 - 1<br>
 
 ## Idea
 
 ## Code
 ```python
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
 class Solution:
-    def longestMountain(self, A: List[int]) -> int:
-        total = 0
-        
-        length = len(A)
-        if length <= 2:
-            return 0
+    def isValidBST(self, root: TreeNode) -> bool:
 
-        pointer = 0
 
-        while pointer <= length-2:
-            base = pointer
-            while pointer + 1 < length and A[pointer] < A[pointer+1]:
-                pointer += 1
+        def preorder(root, left, right):
+            if not root:
+                return True
+            if not left < root.val < right:
+                return False
 
-            if pointer == base:
-                pointer += 1
-                continue
-            
-            peak = pointer
-            while pointer + 1 < length and A[pointer] > A[pointer+1]:
-                pointer += 1
-            
-            if peak == pointer:
-                continue
-                
-            total = max(total, pointer - base + 1)
+            return (preorder(root.left, left, root.val) and preorder(root.right, root.val, right))
+        
+        return preorder(root, float("-inf"), float("inf"))
 
-        return total
 
 ```
 

Daily-challenge/Dec/16/sol.py

@@ -1,29 +1,20 @@
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
 class Solution:
-    def longestMountain(self, A: List[int]) -> int:
-        total = 0
+    def isValidBST(self, root: TreeNode) -> bool:
 
-        length = len(A)
-        if length <= 2:
-            return 0
 
-        pointer = 0
-        
-        while pointer <= length-2:
-            base = pointer
-            while pointer + 1 < length and A[pointer] < A[pointer+1]:
-                pointer += 1
-            
-            if pointer == base:
-                pointer += 1
-                continue
-            
-            peak = pointer
-            while pointer + 1 < length and A[pointer] > A[pointer+1]:
-                pointer += 1
+        def preorder(root, left, right):
+            if not root:
+                return True
+            if not left < root.val < right:
+                return False
 
-            if peak == pointer:
-                continue
-                
-            total = max(total, pointer - base + 1)
-            
-        return total
+            return (preorder(root.left, left, root.val) and preorder(root.right, root.val, right))
+        
+        return preorder(root, float("-inf"), float("inf"))
+