12/12/2020

Author: jameszu

Daily-challenge/Dec/11/README.md

@@ -44,15 +44,27 @@ nums is sorted in ascending order.<br>
 ## Code
 ```python
 class Solution:
-    def validSquare(self, p1, p2, p3, p4):
-        if p1==p2==p3==p4:return False
-        def dist(x,y):
-            return (x[0]-y[0])**2+(x[1]-y[1])**2
-        ls=[dist(p1,p2),dist(p1,p3),dist(p1,p4),dist(p2,p3),dist(p2,p4),dist(p3,p4)]
-        ls.sort()
-        if ls[0]==ls[1]==ls[2]==ls[3]:
-            if ls[4]==ls[5]:
-                return True
-        return False
+    def removeDuplicates(self, nums: List[int]) -> int:
+        if len(nums) <= 1:
+            return len(nums)
+        idx = 0
+        
+        count = 0
+        
+        while idx < len(nums)-1:
+            # print(idx)
+            if nums[idx] == nums[idx+1]:
+                count += 1
+            if nums[idx] != nums[idx+1]:
+                count = 0
+
+                
+            if count >= 2:
+                del nums[idx]
+            else:
+                idx += 1
+        return len(nums)
+                
+            
 ```
 

Daily-challenge/Dec/11/sol.py

@@ -1,11 +1,23 @@
 class Solution:
-    def validSquare(self, p1, p2, p3, p4):
-        if p1==p2==p3==p4:return False
-        def dist(x,y):
-            return (x[0]-y[0])**2+(x[1]-y[1])**2
-        ls=[dist(p1,p2),dist(p1,p3),dist(p1,p4),dist(p2,p3),dist(p2,p4),dist(p3,p4)]
-        ls.sort()
-        if ls[0]==ls[1]==ls[2]==ls[3]:
-            if ls[4]==ls[5]:
-                return True
-        return False
+    def removeDuplicates(self, nums: List[int]) -> int:
+        if len(nums) <= 1:
+            return len(nums)
+        idx = 0
+        
+        count = 0
+        
+        while idx < len(nums)-1:
+            # print(idx)
+            if nums[idx] == nums[idx+1]:
+                count += 1
+            if nums[idx] != nums[idx+1]:
+                count = 0
+
+                
+            if count >= 2:
+                del nums[idx]
+            else:
+                idx += 1
+        return len(nums)
+                
+            

Daily-challenge/Dec/12/README.md

@@ -1,27 +1,41 @@
-# Permutations II
+# Smallest Subtree with all the Deepest Nodes
+Given the root of a binary tree, the depth of each node is the shortest distance to the root.
 
-Solution
-Given a collection of numbers, nums, that might contain duplicates, return all possible unique permutations in any order.
+Return the smallest subtree such that it contains all the deepest nodes in the original tree.
+
+A node is called the deepest if it has the largest depth possible among any node in the entire tree.
+
+The subtree of a node is tree consisting of that node, plus the set of all descendants of that node.
+
+Note: This question is the same as 1123: https://leetcode.com/problems/lowest-common-ancestor-of-deepest-leaves/
 
 
 
 Example 1:
 
-Input: nums = [1,1,2]
-Output:
-[[1,1,2],
- [1,2,1],
- [2,1,1]]
+
+Input: root = [3,5,1,6,2,0,8,null,null,7,4]
+Output: [2,7,4]
+Explanation: We return the node with value 2, colored in yellow in the diagram.
+The nodes coloured in blue are the deepest nodes of the tree.
+Notice that nodes 5, 3 and 2 contain the deepest nodes in the tree but node 2 is the smallest subtree among them, so we return it.
 Example 2:
 
-Input: nums = [1,2,3]
-Output: [[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]
+Input: root = [1]
+Output: [1]
+Explanation: The root is the deepest node in the tree.
+Example 3:
+
+Input: root = [0,1,3,null,2]
+Output: [2]
+Explanation: The deepest node in the tree is 2, the valid subtrees are the subtrees of nodes 2, 1 and 0 but the subtree of node 2 is the smallest.
 
 
 Constraints:
 
-1 <= nums.length <= 8
--10 <= nums[i] <= 10 <br>
+The number of nodes in the tree will be in the range [1, 500].
+0 <= Node.val <= 500
+The values of the nodes in the tree are unique. <br>
 
 ## Idea