no message

Author: wuduhren

problems/python/substring-with-concatenation-of-all-words.py

@@ -47,4 +47,6 @@ def test(self, s, wl, countExpected):
 
         return True
 
-        
+
+
+

problems/python3/3sum-smaller.py

@@ -0,0 +1,18 @@
+class Solution:
+    def threeSumSmaller(self, nums: List[int], target: int) -> int:
+        N = len(nums)
+        ans = 0
+        
+        nums.sort()
+        
+        
+        for i in range(N):
+            j = i+1
+            k = N-1
+            while j<k:
+                if nums[i]+nums[j]+nums[k]<target:
+                    ans += k-j
+                    j += 1
+                else:
+                    k -= 1
+        return ans

problems/python3/3sum.py

@@ -37,4 +37,28 @@ def threeSum(self, nums: List[int]) -> List[List[int]]:
                     k -= 1
                     j += 1
 
+        return ans
+
+
+"""
+No Sort.
+Use set to dedupe and check needed.
+
+Time: O(N^2)
+Space: O(N)
+"""
+class Solution:
+    def threeSum(self, nums: List[int]) -> List[List[int]]:
+        ans = set()
+        seen = set()
+        N = len(nums)
+        
+        for i, v1 in enumerate(nums):
+            if v1 in seen: continue
+            seen.add(v1)
+            needed = set()
+            for j, v2 in enumerate(nums[i+1:]):
+                if v2 in needed:
+                    ans.add(tuple(sorted((v1, v2, -v1-v2))))
+                needed.add(-v1-v2)
         return ans

problems/python3/4sum.py

@@ -0,0 +1,33 @@
+"""
+Time: O(N^(K-1)) -> O(N^3)
+Space: O(K) -> O(1)
+"""
+class Solution:
+    def fourSum(self, nums: List[int], target: int) -> List[List[int]]:
+        def kSum(k, start, target):
+            if k>2:
+                for i in range(start, len(nums)-k+1):
+                    if i!=start and nums[i]==nums[i-1]: continue
+                    temp.append(nums[i])
+                    kSum(k-1, i+1, target-nums[i])
+                    temp.pop()
+            else:
+                l, r = start, len(nums)-1
+                
+                while l<r:
+                    if nums[l]+nums[r]>target:
+                        r -= 1
+                    elif nums[l]+nums[r]<target:
+                        l += 1
+                    else:
+                        ans.append(temp+[nums[l], nums[r]])
+                        while l<r and nums[l+1]==nums[l]: l += 1
+                        while l<r and nums[r-1]==nums[r]: r -= 1
+                        l += 1
+                        r -= 1
+                        
+        ans = []
+        temp = []
+        nums.sort()
+        kSum(4, 0, target)
+        return ans

problems/python3/balanced-binary-tree.py

@@ -0,0 +1,18 @@
+"""
+Time: O(N)
+Space: O(LogN) Recursion stack. If the tree is balanced.
+"""
+class Solution:
+    def isBalanced(self, root: Optional[TreeNode]) -> bool:
+        def getHeight(node) -> (bool, int):
+            if not node: return True, 0
+            leftIsBalanced, leftHeight = getHeight(node.left)
+            if not leftIsBalanced: return False, 0
+            
+            rightIsBalanced, rightHeight = getHeight(node.right)
+            if not rightIsBalanced: return False, 0
+            
+            return abs(leftHeight-rightHeight)<2, 1+max(leftHeight, rightHeight)
+        
+        isBalanced, h = getHeight(root)
+        return isBalanced

problems/python3/diameter-of-binary-tree.py

@@ -0,0 +1,17 @@
+"""
+Time: O(N)
+Space: O(LogN) for the recursion stack. If the tree is balanced.
+"""
+class Solution:
+    def diameterOfBinaryTree(self, root: Optional[TreeNode]) -> int:
+        def helper(node):
+            if not node: return 0
+            l = helper(node.left)
+            r = helper(node.right)
+            self.ans = max(self.ans, 1+l+r)
+            return 1+max(l, r)
+        
+        self.ans = 0
+        
+        helper(root)
+        return self.ans-1

problems/python3/invert-binary-tree.py

@@ -0,0 +1,36 @@
+"""
+Recursive
+Time: O(N)
+Space: O(LogN)
+"""
+class Solution:
+    def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
+        if not root: return root
+        left = root.left
+        right = root.right
+        root.left = self.invertTree(right)
+        root.right = self.invertTree(left)
+        return root
+
+
+"""
+Iterative
+Time: O(N)
+Space: O(N)
+"""
+class Solution:
+    def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
+        if not root: return root
+        q = collections.deque([root])
+        
+        while q:
+            node = q.popleft()
+            left = node.left
+            right = node.right
+            node.right = left
+            node.left = right
+            
+            if node.left: q.append(node.left)
+            if node.right: q.append(node.right)
+        
+        return root

problems/python3/maximum-depth-of-binary-tree.py

@@ -0,0 +1,8 @@
+"""
+Time: O(N)
+Space:O(LogN), for recursion stack space.
+"""
+class Solution:
+    def maxDepth(self, root: Optional[TreeNode]) -> int:
+        if not root: return 0
+        return 1+max(self.maxDepth(root.left), self.maxDepth(root.right))

problems/python3/substring-with-concatenation-of-all-words.py

@@ -0,0 +1,46 @@
+"""
+Time: O(W * N/W * W), there will be W time of iteration in the first loop ([0]), N/W of iteration in the second loop ([1]). In each loop, creating substring "word" and "popWord" takes O(W).
+Space: O(MW) for "wordSet".
+"""
+class Solution:
+    def findSubstring(self, s: str, words: List[str]) -> List[int]:
+        N = len(s)
+        M = len(words)
+        W = len(words[0])
+        wordSet = set(words)
+        ans = []
+        counter = collections.Counter(words)
+        
+        for i in range(W): #[0]
+            windowCounter = collections.Counter() #counter for the word in words
+            notInWords = 0 #number of word not in the wordSet
+            theSame = 0 #number of word with the same count with "counter"
+            j = i
+            
+            while j<N: #[1]
+                word = s[j:j+W]
+                if word in wordSet:
+                    windowCounter[word] += 1
+                    if windowCounter[word]==counter[word]:
+                        theSame += 1
+                    elif windowCounter[word]>counter[word]:
+                        theSame -= 1
+                else:
+                    notInWords += 1
+                    
+                popStart = j-M*W
+                if popStart>=0:
+                    popWord = s[popStart:popStart+W]
+                    if popWord in wordSet:
+                        windowCounter[popWord] -= 1
+                        if windowCounter[popWord]==counter[popWord]:
+                            theSame += 1
+                        elif windowCounter[popWord]<counter[popWord]:
+                            theSame -= 1
+                    else:
+                        notInWords -= 1
+                
+                if theSame==len(wordSet) and notInWords==0: ans.append(popStart+W)
+                j += W
+                
+        return ans