no message

Author: Chris Wu

problems/3sum-closest.py

@@ -0,0 +1,24 @@
+class Solution(object):
+    def threeSumClosest(self, nums, target):
+        ans = float('inf')
+        N = len(nums)
+        
+        nums.sort()
+        
+        for i in xrange(N):
+            l = i+1
+            r = N-1
+            
+            while l<r:
+                s = nums[i]+nums[l]+nums[r]
+                
+                if abs(target-s)<abs(target-ans): ans = s
+                
+                if s>target:
+                    r -= 1
+                elif s<target:
+                    l += 1
+                else:
+                    return s
+        
+        return ans

problems/3sum.py

@@ -102,3 +102,104 @@ def twoSum(target, nums):
 
         return res
     """
+
+
+
+#2021/7/5
+"""
+Hash Table
+Time: O(N^2)
+Space: O(N)
+
+memo := {num:[index1, index2,...]}
+Iterate through every i and j, see if the required number exist in memo.
+"""
+import collections
+class Solution(object):
+    def threeSum(self, nums):
+        memo = collections.defaultdict(list)
+        N = len(nums)
+        ans = set()
+        
+        for k in xrange(N):
+            memo[nums[k]].append(k)
+        
+        for i in xrange(N):
+            for j in xrange(i+1, N):
+                t = (nums[i]+nums[j])*-1
+                
+                for k in memo[t]:
+                    if k!=i and k!=j:
+                        ans.add(tuple(sorted([nums[i], nums[j], nums[k]])))
+                        break
+        return ans
+
+"""
+Two Pointers
+Time: O(N^2)
+Space: O(1)
+
+Sort the nums.
+Iterate through i.
+j = i+1 and k = N-1, see if the sum s equals to 0.
+if s>0, means that we need to reduce the s and it can only be done by decreasing k.
+if s<0, means that we need to increase the s and it can only be done by increasing j.
+"""
+class Solution(object):
+    def threeSum(self, nums):
+        nums.sort()
+        ans = set()
+        N = len(nums)
+        
+        for i in xrange(N):
+            j = i+1
+            k = N-1
+            
+            while j<k:
+                s = nums[i]+nums[j]+nums[k]
+                if s>0:
+                    k -= 1
+                elif s<0:
+                    j += 1
+                else:
+                    ans.add(tuple(sorted([nums[i], nums[j], nums[k]])))
+                    k -= 1
+                    j += 1
+                    
+        return ans
+
+"""
+Two Pointers
+Time: O(N^2)
+Space: O(1)
+
+Same as above. Move pointers to avoid repeation. Faster.
+"""
+class Solution(object):
+    def threeSum(self, nums):
+        nums.sort()
+        ans = []
+        N = len(nums)
+        
+        for i in xrange(N):
+            j = i+1
+            k = N-1
+            
+            if i>0 and nums[i]==nums[i-1]: continue #[1]
+            
+            while j<k:
+                s = nums[i]+nums[j]+nums[k]
+                
+                if s>0:
+                    k -= 1
+                elif s<0:
+                    j += 1
+                else:
+                    ans.append([nums[i], nums[j], nums[k]])
+                    
+                    while j<k and nums[k]==nums[k-1]: k -= 1 #[2]
+                    while j<k and nums[j]==nums[j+1]: j += 1 #[3]
+                    k -= 1
+                    j += 1
+                    
+        return ans

problems/4sum.py

@@ -0,0 +1,64 @@
+"""
+Time: O(N^3)
+Space: O(1)
+
+Using tuple to remove redundant, each `ans.add(tuple(sorted([nums[a], nums[b], nums[c], nums[d]])))` is using constant time and space.
+So no increase to the time and space complexity.
+"""
+class Solution(object):
+    def fourSum(self, nums, target):
+        nums.sort()
+        N = len(nums)
+        ans = set()
+        
+        for a in xrange(N):
+            for b in xrange(a+1, N):
+                c = b+1
+                d = N-1
+                
+                while c<d:
+                    s = nums[a]+nums[b]+nums[c]+nums[d]
+                    
+                    if s>target:
+                        d -= 1
+                    elif s<target:
+                        c += 1
+                    else:
+                        ans.add(tuple(sorted([nums[a], nums[b], nums[c], nums[d]])))
+                        d -= 1
+                        c += 1
+        return ans
+
+"""
+Remove tuple by skipping the same value for each a, b, c and d.
+I find that doing this does not improve overall run time.
+"""
+class Solution(object):
+    def fourSum(self, nums, target):
+        nums.sort()
+        N = len(nums)
+        ans = []
+        
+        for a in xrange(N):
+            if a>0 and nums[a]==nums[a-1]: continue
+            for b in xrange(a+1, N):
+                if b>0 and nums[b]==nums[b-1] and a!=b-1: continue
+                c = b+1
+                d = N-1
+                
+                while c<d:
+                    s = nums[a]+nums[b]+nums[c]+nums[d]
+                    
+                    if s>target:
+                        d -= 1
+                    elif s<target:
+                        c += 1
+                    else:
+                        ans.append([nums[a], nums[b], nums[c], nums[d]])
+                        
+                        while c<d and nums[c]==nums[c+1]: c+=1
+                        while c<d and nums[d]==nums[d-1]: d-=1
+                        
+                        d -= 1
+                        c += 1
+        return ans

problems/intersection-of-two-arrays-ii.py

@@ -0,0 +1,43 @@
+"""
+Time: O(NLogN)
+Space: O(1)
+"""
+class Solution(object):
+    def intersect(self, nums1, nums2):
+        nums1.sort()
+        nums2.sort()
+        
+        i = j = 0
+        ans = []
+        
+        while i<len(nums1) and j<len(nums2):
+            if nums1[i]==nums2[j]:
+                ans.append(nums1[i])
+                i += 1
+                j +=1
+            elif nums1[i]>nums2[j]:
+                j += 1
+            else:
+                i += 1
+        return ans
+
+"""
+Time: O(N)
+Space: O(N)
+"""
+class Solution(object):
+    def intersect(self, nums1, nums2):
+        c = {} #nums1 counter
+        ans = []
+        
+        for n in nums1:
+            if n in c:
+                c[n] += 1
+            else:
+                c[n] = 1
+        
+        for n in nums2:
+            if n in c and c[n]>0:
+                ans.append(n)
+                c[n] -= 1
+        return ans

problems/intersection-of-two-arrays.py

@@ -19,4 +19,12 @@ def intersection(self, nums1, nums2):
     #element in set is not repeated
     #set has some convenient build-in operator
     def intersection(self, nums1, nums2):
-        return list(set(nums1) & set(nums2))
+        return list(set(nums1) & set(nums2))
+
+
+class Solution(object):
+    def intersection(self, nums1, nums2):
+        nums1 = set(nums1)
+        nums2 = set(nums2)
+        
+        return nums1.intersection(nums2)

problems/two-sum.py

@@ -30,4 +30,16 @@ def twoSum(self, nums, target):
             if num in M: return (M[num], i)
             M[target-num] = i
 
-        return False
+        return False
+
+#2021/7/4
+class Solution(object):
+    def twoSum(self, nums, target):
+        memo = {} #{key : value} := {"counter part needed for n" : "index of n"}
+        
+        for i, n in enumerate(nums):
+            if n in memo:
+                return [memo[n], i]
+            else:
+                memo[target-n] = i
+        return []

problems/wiggle-subsequence.py

@@ -0,0 +1,64 @@
+"""
+dp[0][0 or 1] is considering no num in nums.
+dp[1][0 or 1] is considering the first num in nums.
+dp[2][0 or 1] is considering the second num in nums.
+dp[3][0 or 1] is considering the third num in nums.
+...
+
+dp[i][0] := longest length of wiggle seq that ends at nums[i-1] and diff ends in positive number.
+dp[i][1] := longest length of wiggle seq that ends at nums[i-1] and diff ends in negative number.
+
+Time: O(N)
+Space: O(N)
+"""
+class Solution(object):
+    def wiggleMaxLength(self, nums):
+        ans = 1
+        N = len(nums)
+        
+        dp = [[0, 0] for _ in xrange(N+1)]
+        dp[1][0] = 1
+        dp[1][1] = 1
+        
+        for i in xrange(2, N+1):
+            if nums[i-1]-nums[i-2]>0:
+                dp[i][0] = dp[i-1][1]+1
+                dp[i][1] = dp[i-1][1]
+            elif nums[i-1]-nums[i-2]<0:
+                dp[i][1] = dp[i-1][0]+1
+                dp[i][0] = dp[i-1][0]
+            else:
+                dp[i][1] = dp[i-1][1]
+                dp[i][0] = dp[i-1][0]
+                
+            ans = max(ans, dp[i][0], dp[i][1])
+
+        return ans
+
+"""
+From the above solution, we notice that we do not need whole array to keep track.
+Just need two variables.
+Use `up` and `down` to replace dp[i-1][0] and dp[i-1][1]
+
+Time: O(N)
+Space: O(1)
+"""
+class Solution(object):
+    def wiggleMaxLength(self, nums):
+        N = len(nums)
+        
+        ans = 1
+        up = 1
+        down = 1
+        
+        for i in xrange(2, N+1):
+            if nums[i-1]-nums[i-2]>0:
+                up, down = down+1, down
+            elif nums[i-1]-nums[i-2]<0:
+                down = up+1
+                
+            ans = max(ans, up, down)
+
+        return ans
+
+