no message

Author: Chris Wu

problems/delete-and-earn.py

@@ -0,0 +1,14 @@
+import collections
+
+class Solution(object):
+    def deleteAndEarn(self, nums):
+        if not nums: return 0
+        m = min(nums)
+        M = max(nums)
+        c = collections.Counter(nums)
+        
+        prev = 0 
+        curr = 0
+        for n in xrange(m, M+1):
+            prev, curr = curr, max(prev+n*c[n], curr)
+        return curr

problems/domino-and-tromino-tiling.py

@@ -0,0 +1,11 @@
+class Solution(object):
+    def numTilings(self, N):
+        H = [[0, 0] for _ in xrange(N+1)]
+        H[0][0] = 1
+        H[1][0] = 1
+        
+        for i in xrange(2, N+1):
+            H[i][0] = (H[i-1][0] + H[i-2][0] + H[i-1][1]*2) % 1000000007
+            H[i][1] = (H[i-2][0] + H[i-1][1]) % 1000000007
+            
+        return H[N][0]

problems/minimum-swaps-to-make-sequences-increasing.py

@@ -0,0 +1,19 @@
+class Solution(object):
+    def minSwap(self, A, B):
+        keep = [float('inf') for _ in xrange(len(A))]
+        swap = [float('inf') for _ in xrange(len(A))]
+        
+        keep[0] = 0
+        swap[0] = 1
+        
+        for i in xrange(1, len(A)):
+            
+            if A[i]>A[i-1] and B[i]>B[i-1]:
+                keep[i] = keep[i-1]
+                swap[i] = swap[i-1]+1
+                
+            if A[i]>B[i-1] and B[i]>A[i-1]:
+                keep[i] = min(keep[i], swap[i-1])
+                swap[i] = min(swap[i], keep[i-1]+1)
+                
+        return min(keep[-1], swap[-1])

problems/perfect-squares.py

@@ -0,0 +1,39 @@
+#Recursive
+class Solution(object):
+    def numSquares(self, n):
+        def helper(n):
+            if not n: return 0
+            if n in history: return history[n]
+            
+            elements = [e**2 for e in range(2, int(n**0.5)+1)]
+            ans = n
+
+            for e in reversed(elements):
+                count_of_element = int(n/e)
+                n_approximate = count_of_element*e
+                ans = min(ans, count_of_element+helper(n-n_approximate))
+            
+            history[n] = ans
+            return history[n]
+        
+        history = {1:1, 2:2, 3:3}
+        return helper(n)
+
+#DP
+class Solution(object):
+    def numSquares(self, N):
+        squares = [s**2 for s in range(2, int(N**0.5)+1)]
+        
+        dp = [n for n in xrange(N+1)]
+        
+        for n in xrange(N+1):
+            for square in squares:
+                if square>n:
+                    break
+                elif square==n:
+                    dp[n] = 1
+                    break
+                else:
+                    dp[n] = min(dp[n], dp[square]+dp[n-square])
+        return dp[N]
+        

problems/word-break.py

@@ -0,0 +1,17 @@
+class Solution(object):
+    def wordBreak(self, s, wordDict):
+        def helper(s_left):
+            if not s_left: return True
+            if s_left in history: return history[s_left]
+            
+            for word in wordDict:
+                if len(s_left)<len(word): continue
+                if s_left[:len(word)]==word and helper(s_left[len(word):]):
+                    history[s_left] = True
+                    return history[s_left]
+            
+            history[s_left] = False
+            return history[s_left]
+        
+        history = {}
+        return helper(s)