no message

Author: Chris Wu

README.md

@@ -11,6 +11,9 @@ https://github.com/wuduhren/leetcode-python
 For example, `merge-sorted-array.py`'s solution is at `https://leetcode.com/problems/merge-sorted-array/`.
 
 
+# Leetcode 74 Classic Problem
+https://leetcode.com/list/?selectedList=535ukjh5
+
 # Leetcode Similar Problems
 I found it makes sense to solve similar problems together, so that we can recognize the problem faster when we encounter a new one. My suggestion is to skip the HARD problems when you first go through these list.
 
@@ -188,6 +191,8 @@ If you are new or know nothing about data structures and algorithms, I recommend
 
 4. [Narendra's Youtube Channel](https://www.youtube.com/channel/UCn1XnDWhsLS5URXTi5wtFTA/playlists)
 
+5. [System Design Primer](https://github.com/donnemartin/system-design-primer)
+
 
 # Knowledge Base Question
 1. [Session vs Cookie](https://medium.com/@chriswrite/session-vs-cookie-software-engineer-top-asked-question-1-9bdbc0766739)

problems/greatest-sum-divisible-by-three.py

@@ -0,0 +1,66 @@
+#DP
+"""
+Time: O(N)
+Space: O(N). Can reduce to O(1).
+
+dp[i][0] max number n, which n%3==0, considering nums[0~i-1]
+dp[i][1] max number n, which n%3==1, considering nums[0~i-1]
+dp[i][2] max number n, which n%3==2, considering nums[0~i-1]
+"""
+class Solution(object):
+    def maxSumDivThree(self, nums):
+        dp = [[0]*3 for _ in xrange(len(nums)+1)]
+        
+        for i in xrange(len(nums)+1):
+            if i==0:
+                dp[i][0] = 0
+                dp[i][1] = float('-inf')
+                dp[i][2] = float('-inf')
+                continue
+            
+            n = nums[i-1]
+            
+            if n%3==0:
+                dp[i][0] = max(dp[i-1][0], dp[i-1][0]+n)
+                dp[i][1] = max(dp[i-1][1], dp[i-1][1]+n)
+                dp[i][2] = max(dp[i-1][2], dp[i-1][2]+n)
+            elif n%3==1:
+                dp[i][0] = max(dp[i-1][0], dp[i-1][2]+n)
+                dp[i][1] = max(dp[i-1][1], dp[i-1][0]+n)
+                dp[i][2] = max(dp[i-1][2], dp[i-1][1]+n)
+            elif n%3==2:
+                dp[i][0] = max(dp[i-1][0], dp[i-1][1]+n)
+                dp[i][1] = max(dp[i-1][1], dp[i-1][2]+n)
+                dp[i][2] = max(dp[i-1][2], dp[i-1][0]+n)
+            
+        return dp[-1][0]
+
+# Greedy
+class Solution(object):
+    def videoStitching(self, clips, T):
+        if T==0: return 0
+        if not clips: return -1
+        
+        clips.sort()
+        print clips
+        
+        if clips[0][0]!=0: return -1
+        if clips[0][1]>=T: return 1
+        
+        count = 0
+        i = 0
+        rightMost = 0
+        
+        while i<len(clips):
+            right = rightMost
+            while i<len(clips) and clips[i][0]<=rightMost:
+                right = max(right, clips[i][1])
+                i += 1
+            
+            if rightMost==right: return -1 #rightMost cannot be update anymore
+            
+            rightMost = right
+            count += 1
+            if rightMost >= T: return count
+            
+        return -1

problems/minimum-score-triangulation-of-polygon.py

@@ -0,0 +1,16 @@
+class Solution(object):
+    def minScoreTriangulation(self, values):
+        N = len(values)
+        dp = [[float('inf')]*N for _ in xrange(N)]
+        
+        for i in xrange(N-1):
+            dp[i][i+1] = 0
+        
+        for l in xrange(3, N+1):
+            for i in xrange(N-l+1):
+                j = i+l-1
+                
+                for k in xrange(i+1, j):
+                    dp[i][j] = min(dp[i][j], dp[i][k]+values[i]*values[k]*values[j]+dp[k][j])
+        return dp[0][N-1]
+            

problems/partition-array-for-maximum-sum.py

@@ -1,5 +1,5 @@
 """
-dp[i] = maxSumAfterPartitioning(A[0~i-1], K) and must contain A[i-1]
+dp[i] = max(k*max(A[i-k]~A[i]) + dp[i-k]) for k in 1~K.
 """
 class Solution(object):
     def maxSumAfterPartitioning(self, A, K):

problems/stone-game-ii.py

@@ -0,0 +1,17 @@
+class Solution(object):
+    def stoneGameII(self, piles):
+        def helper(start, m):
+            if (start, m) in history: return history[(start, m)]
+            
+            if start>=len(piles): return 0
+            if start+m*2>=len(piles): return sum(piles[start:])
+            
+            stones = float('-inf')
+            for x in xrange(1, m*2+1):
+                stones = max(stones, sum(piles[start:])-helper(start+x, max(m, x)))
+            
+            history[(start, m)] = stones
+            return history[(start, m)]
+        
+        history = {}
+        return helper(0, 1)

problems/target-sum.py

@@ -13,10 +13,14 @@ def findTargetSumWays(self, nums, S):
 
         return ans
 
-import collections
-
+"""
+dp[i][j] = number of ways to sum to j using nums[0~i-1]
+Time: O(SN)
+Space: O(SN)
+"""
 
 
+import collections
 class Solution(object):
     def findTargetSumWays(self, nums, target):
         S = sum(nums)