no message

Author: Chris Wu

problems/last-stone-weight-ii.py

@@ -27,3 +27,25 @@ def lastStoneWeightII(self, stones):
         # Two collection of stones will be total-maxSum and maxSum
         # (total-maxSum) - maxSum => total-maxSum*2
         return total-maxSum*2
+
+
+"""
+dp[i][w] := if weight w is achievable using stones[:i]
+Find the smallest achivable w where w>=0.
+"""
+import collections
+class Solution(object):
+    def lastStoneWeightII(self, stones):
+        N = len(stones)
+        W = sum(stones)
+        dp = [collections.defaultdict(bool) for _ in xrange(N+1)]
+        dp[0][0] = True
+        
+        for i in xrange(1, N+1):
+            for w in xrange(-W, W+1):
+                dp[i][w] = dp[i-1][w+stones[i-1]] or dp[i-1][w-stones[i-1]]
+        
+        for w, b in dp[N].iteritems():
+            if b and w>=0: return w
+        
+        return 0

problems/longest-palindromic-substring.py

@@ -41,4 +41,26 @@ def findPalindorome(mid, mid2=None):
             max_pal = p2 if len(p2)>len(max_pal) else max_pal
 
         return max_pal
-        
+
+
+#2021/6/18 DP TLE
+"""
+dp[i][j] := if s[i:j+1] is palindrom
+"""
+class Solution(object):
+    def longestPalindrome(self, s):
+        if not s: return s
+        
+        N = len(s)
+        dp = [[False for _ in xrange(N+1)] for _ in xrange(N+1)]
+        for i in xrange(N+1): dp[i][i] = True
+        ans = s[0]    
+        
+        for l in xrange(2, N+1):
+            for i in xrange(1, N+1):
+                j = i+l-1
+                if j>N: continue
+                dp[i][j] = s[i-1]==s[j-1] and (dp[i+1][j-1] or j-1<i+1)
+                if dp[i][j]: ans = s[i-1:j]
+        
+        return ans

problems/ones-and-zeroes.py

@@ -0,0 +1,22 @@
+"""
+dp[i][n][m] := max size of the subset with total m 0's and n 1's.
+Find max size for each m<=M and n<=N.
+"""
+class Solution(object):
+    def findMaxForm(self, strs, M, N):
+        dp = [[[0 for _ in xrange(M+1)] for _ in xrange(N+1)] for _ in xrange(len(strs)+1)]
+        
+        for i in xrange(1, len(strs)+1):
+            count0 = strs[i-1].count('0')
+            count1 = len(strs[i-1])-count0
+
+            for n in xrange(N+1):
+                for m in xrange(M+1):
+                    dp[i][n][m] = max(dp[i-1][n][m], (dp[i-1][n-count1][m-count0]+1) if m>=count0 and n>=count1 else 0)
+        
+        ans = 0
+        for n in xrange(N+1):
+                for m in xrange(M+1):
+                    ans = max(ans, dp[-1][n][m])
+            
+        return ans

problems/profitable-schemes.py

@@ -0,0 +1,19 @@
+"""
+TLE
+dp[i][n][p] := considering profit[:i], what is the number of ways produce profit p with n people.
+"""
+class Solution(object):
+    def profitableSchemes(self, maxMember, minProfit, group, profit):
+        P = sum(profit)
+        N = sum(group)
+        dp = [[[0 for _ in xrange(P+1)] for _ in xrange(N+1)] for _ in xrange(len(profit)+1)]
+        dp[0][0][0] = 1
+        
+        count = 0
+        for i in xrange(1, len(profit)+1):
+            for n in xrange(N+1):
+                for p in xrange(P+1):
+                    dp[i][n][p] = (dp[i-1][n-group[i-1]][p-profit[i-1]] if p-profit[i-1]>=0 and n-group[i-1]>=0 else 0) + dp[i-1][n][p]
+                    if i==len(profit) and p>=minProfit and n<=maxMember: count += dp[i][n][p]
+        return count
+        

problems/remove-duplicates-from-sorted-array.py

@@ -0,0 +1,12 @@
+"""
+j is the index to insert when a new number are found.
+j will never catch up i, so j will not mess up the check.
+"""
+class Solution(object):
+    def removeDuplicates(self, nums):
+        j = 1
+        for i in xrange(1, len(nums)):
+            if nums[i]!=nums[i-1]:
+                nums[j] = nums[i]
+                j += 1
+        return j

problems/tallest-billboard.py

@@ -0,0 +1,15 @@
+#TLE
+class Solution(object):
+    def tallestBillboard(self, rods):
+        D = sum(rods)
+        N = len(rods)
+        
+        dp = [[float('-inf') for _ in xrange(-D, D+1)] for _ in xrange(N+1)]
+        dp[0][D] = 0
+        
+        for i in xrange(1, N+1):
+            for d in xrange(-D, D+1):
+                h = rods[i-1]
+                dp[i][d+D] = max(dp[i-1][d+D], (dp[i-1][d+D-h]+h) if d+D-h>=0 else float('-inf'), dp[i-1][d+D+h] if d+D+h<2*D+1 else float('-inf'))
+        
+        return dp[N][D]

problems/target-sum.py

@@ -32,4 +32,27 @@ def findTargetSumWays(self, nums, target):
                 dp[i][j] = dp[i-1][j+nums[i-1]] + dp[i-1][j-nums[i-1]]
 
         return dp[len(nums)][target]
-        
+
+
+#2021/6/7
+"""
+dp[i][t] := number of ways nums[:i] can sum up to t applying + or -.
+For all i, calculate all posible target (From minTarget~maxTarget)
+"""
+class Solution(object):
+    def findTargetSumWays(self, nums, target):
+        N = len(nums)
+        maxTarget = sum(nums)
+        minTarget = -maxTarget
+        
+        if target<minTarget or target>maxTarget: return 0
+        
+        dp = [[0 for _ in xrange(minTarget, maxTarget+1)] for _ in xrange(N+1)]
+        
+        dp[0][0] = 1
+        
+        for i in xrange(1, N+1):
+            for t in xrange(minTarget, maxTarget+1):
+                dp[i][t] = (dp[i-1][t-nums[i-1]] if t-nums[i-1]>=minTarget else 0) + (dp[i-1][t+nums[i-1]] if t+nums[i-1]<=maxTarget else 0)
+        
+        return dp[N][target]