no message

Author: Chris Wu

problems/burst-balloons.py

@@ -0,0 +1,28 @@
+"""
+dp[i][j] := max coins gains from nums[i+1:j]
+Assume k is the last balloon that get burst within nums[i:j+1], try different k and get the max dp[i][j].
+
+max coins gains from nums[i+1:j] will be the sum of
+1. max coins gains from nums[i:k]: `dp[i][k-1] if k-1>=0 else 0`
+2. coins gains from bursring k: `(nums[i-1] if 0<=i-1 else 1) * nums[k] * (nums[j+1] if j+1<N else 1)`
+3. max coins gains from nums[k+1:j+1]: `dp[k+1][j] if k+1<N else 0`
+"""
+class Solution(object):
+    def maxCoins(self, nums):
+        N = len(nums)
+        
+        dp = [[0 for _ in xrange(N)] for _ in xrange(N)]
+        for i in xrange(N): dp[i][i] = (nums[i-1] if 0<=i-1 else 1) * nums[i] * (nums[i+1] if i+1<N else 1)
+            
+        for l in xrange(2, N+1):
+            for i in xrange(N):
+                j = i+l-1
+                if j>=N: continue
+                for k in xrange(i, j+1):
+                    dp[i][j] = max(dp[i][j],
+                        (dp[i][k-1] if k-1>=0 else 0) +
+                        (nums[i-1] if 0<=i-1 else 1) * nums[k] * (nums[j+1] if j+1<N else 1) +
+                        (dp[k+1][j] if k+1<N else 0)
+                    )
+        
+        return dp[0][N-1]

problems/guess-number-higher-or-lower-ii.py

@@ -0,0 +1,18 @@
+"""
+dp[i][j] := min money guarantee to win within i~j
+k is the first guess, try all k and update dp[i][j].
+"""
+class Solution(object):
+    def getMoneyAmount(self, N):
+        dp = [[float('inf') for _ in xrange(N)] for _ in xrange(N)]
+        for i in xrange(N): dp[i][i] = 0
+        
+        
+        for l in xrange(2, N+1):
+            for i in xrange(N):
+                j = i+l-1
+                if j>=N: continue
+                for k in xrange(i, j+1):
+                    dp[i][j] = min(dp[i][j], max(dp[i][k-1] if k-1>=0 else 0, dp[k+1][j] if k+1<N else 0) + (k+1))
+        
+        return dp[0][N-1]

problems/longest-palindromic-subsequence.py

@@ -0,0 +1,17 @@
+"""
+dp[i][j] := longest palindromic subsequence of s[i:j+1]
+"""
+class Solution(object):
+    def longestPalindromeSubseq(self, s):
+        N = len(s)
+
+        dp = [[0 for _ in xrange(N)] for _ in xrange(N)]
+        for i in xrange(N): dp[i][i] = 1
+
+        for l in xrange(2, N+1):
+            for i in xrange(N):
+                j = i+l-1
+                if j>=N: continue
+                dp[i][j] = dp[i+1][j-1]+2 if s[i]==s[j] else max(dp[i+1][j], dp[i][j-1])
+        
+        return dp[0][N-1]

problems/minimum-difficulty-of-a-job-schedule.py

@@ -0,0 +1,29 @@
+"""
+dp[i][k] := minimum difficulty of a k days job schedule, D[:i].
+maxInRange[i][j] := max(D[i:j+1])
+"""
+
+class Solution(object):
+    def minDifficulty(self, D, K):
+        if not D or not K or K>len(D): return -1
+        N = len(D)
+
+        maxInRange = [[0 for _ in xrange(N)] for _ in xrange(N)]
+        for i in xrange(N): maxInRange[i][i] = D[i]
+        for l in xrange(2, N+1):
+            for i in xrange(N):
+                j = i+l-1
+                if j>=N: continue
+                maxInRange[i][j] = max(maxInRange[i+1][j-1], D[i], D[j])
+
+        dp = [[float('inf') for _ in xrange(K+1)] for _ in xrange(N+1)]
+        dp[0][0] = 0
+
+        for i in xrange(1, N+1):
+            for k in xrange(1, min(i, K)+1):
+                for j in xrange(k, i+1):
+                    dp[i][k] = min(dp[i][k], dp[j-1][k-1]+maxInRange[j-1][i-1])
+                    
+                    #if you don't pre-calculate maxInRange
+                    #dp[i][k] = min(dp[i][k], dp[j-1][k-1]+max(D[j-1:i]))
+        return dp[N][K]

problems/split-array-largest-sum.py

@@ -0,0 +1,45 @@
+"""
+TLE
+dp[i][k] := min of the largest sum among k subarrays from nums[:i]
+"""
+class Solution(object):
+    def splitArray(self, nums, K):
+        N = len(nums)
+        
+        dp = [[float('inf') for _ in xrange(K+1)] for _ in xrange(N+1)]
+        dp[0][0] = 0
+        
+        for i in xrange(1, N+1):
+            for k in xrange(1, min(i, K)+1):
+                for j in xrange(k, i+1):
+                    dp[i][k] = min(dp[i][k], max(dp[j-1][k-1], sum(nums[j-1:i])))
+        
+        return dp[N][K]
+
+
+"""
+TLE
+dp[i][k] := min of the largest sum among k subarrays from nums[:i]
+s[i][j] := sum of nums[i:j+1]
+"""
+class Solution(object):
+    def splitArray(self, nums, K):
+        N = len(nums)
+
+        s = [[0 for _ in xrange(N)] for _ in xrange(N)]
+        for i in xrange(N): s[i][i] = nums[i]
+        for l in xrange(2, N):
+            for i in xrange(N):
+                j = i+l-1
+                if j>=N: continue
+                s[i][j] = s[i+1][j-1]+nums[i]+nums[j]
+
+        dp = [[float('inf') for _ in xrange(K+1)] for _ in xrange(N+1)]
+        dp[0][0] = 0
+        
+        for i in xrange(1, N+1):
+            for k in xrange(1, min(i, K)+1):
+                for j in xrange(k, i+1):
+                    dp[i][k] = min(dp[i][k], max(dp[j-1][k-1], s[j-1][i-1]))
+        
+        return dp[N][K]