no message

Author: Chris Wu

problems/best-time-to-buy-and-sell-stock-with-cooldown.py

@@ -0,0 +1,47 @@
+class Solution(object):
+    def maxProfit(self, prices):
+        if not prices or len(prices)<=1: return 0
+        N = len(prices)
+
+        buy = [-prices[0], max(-prices[1], -prices[0])]
+        sell = [0, max(prices[1]+buy[0], 0)]
+        
+        for i in xrange(2, N):
+            buy.append(max(sell[i-2]-prices[i], buy[i-1]))
+            sell.append(max(prices[i]+buy[i-1], sell[i-1]))
+            
+        return max(buy[-1], sell[-1], 0)
+
+"""
+Three rules:
+1. Need to buy before sell.
+2. After sell, next day need to rest (cannot buy).
+3. When buying, we spend money, which is a negative profit.
+
+There are two possible end state. buy or sell. So we need to consider both.
+Only considering prices 0~i, buy[i] stores the max profit that the last action is "buy".
+Only considering prices 0~i, sell[i] stores the max profit that the last action is "sell".
+
+Let's sort this out.
+When i==0:
+buy: -prices[0]
+sell: 0, since we cannot sell at i==0.
+
+When i==1:
+buy: max(-prices[1], -prices[0])
+Now, we must not have sell yet. So no need to consider it.
+If we buy at i==1, the profit will be `-prices[1]`. But we also had the option not to buy. buy[0] is the max profit if we don't buy at i==1.
+Again, we are considering, when the end state is "buy", what is the max profit?
+Thus, `max(-prices[1], buy[0])`.
+
+sell: max(prices[1]+buy[0], 0)
+If we sell at i==1, the profit will be `prices[1]+buy[0]`. But we also had the option not to sell. 0 is the max profit if we don't sell at i==1.
+Again, we are considering, when the end state is "sell", what is the max profit?
+Thus, `max(prices[1]+buy[0], sell[0])`
+
+When i>=2:
+
+
+
+
+"""

problems/best-time-to-buy-and-sell-stock.py

@@ -0,0 +1,16 @@
+"""
+To accomplish 0(N) solution:
+For each i and price in the iteration, we need to keep track of the loest price before i.
+Also, update the max_profit in the iteration.
+"""
+class Solution(object):
+    def maxProfit(self, prices):
+        if not prices: return 0
+        max_profit = 0
+        lowest = prices[0]
+        
+        for i in xrange(len(prices)):
+            if i==0: continue
+            max_profit = max(max_profit, prices[i]-lowest)
+            lowest = min(lowest, prices[i])
+        return max_profit

problems/house-robber-ii.py

@@ -39,4 +39,23 @@ def rob(self, nums):
         		else:
         			K[i] = K[i-1]+nums[i]
         v2 = K[-1]
-        return max(v1, v2)
+        return max(v1, v2)
+
+#2020/11/15
+class Solution(object):
+    def rob(self, nums):
+        if not nums: return 0
+        if len(nums)==0 or len(nums)==1: return max(nums)
+        N = len(nums)
+        
+        v1 = nums[0]
+        v2 = nums[0]
+        for i in xrange(2, N-1):
+            v1, v2 = max(nums[i]+v2, v1), v1
+        
+        w1 = nums[1]
+        w2 = 0
+        for i in xrange(2, N):
+            w1, w2 = max(nums[i]+w2, w1), w1
+        
+        return max(v1, w1)

problems/house-robber.py

@@ -26,4 +26,31 @@ def rob(self, nums):
         			K[i] = max(K[i-2]+nums[i], K[i-1])
         		else: #[2]
         			K[i] = K[i-1]+nums[i]
-        return K[-1]
+        return K[-1]
+
+#2020/11/14
+class Solution(object):
+    def rob(self, nums):
+        def helper(i):
+            if i>=len(nums): return 0
+            if i in history: return history[i]
+            history[i] = max(nums[i]+helper(i+2), helper(i+1))
+            return history[i]
+        
+        history = {}
+        return helper(0)
+
+#2020/11/14
+class Solution(object):
+    def rob(self, nums):
+        if not nums: return 0
+        if len(nums)==0 or len(nums)==1: return max(nums)
+        
+        last1 = max(nums[0], nums[1])
+        last2 = nums[0]
+        
+        for i in xrange(len(nums)):
+            if i==0 or i==1: continue
+            last2, last1 = last1, max(nums[i]+last2, last1)
+            
+        return last1

problems/maximum-subarray.py

@@ -19,4 +19,17 @@ def maxSubArray(self, nums):
         maxCurrent = [nums[0]] #[1]
         for i in xrange(1, len(nums)):
             maxCurrent.append(max(nums[i], nums[i]+maxCurrent[-1])) #[0]
-        return max(maxCurrent) #[2]
+        return max(maxCurrent) #[2]
+
+# 2020/11/14
+class Solution(object):
+    def maxSubArray(self, nums):
+        ans = nums[0]
+        last_max = nums[0]
+        
+        for i in xrange(len(nums)):
+            if i==0: continue
+            last_max = max(nums[i], nums[i]+last_max)
+            ans = max(ans, last_max)
+            
+        return ans

problems/range-sum-query-immutable.py

@@ -0,0 +1,13 @@
+class NumArray(object):
+    def __init__(self, nums):
+        #total[i] = nums[0]+nums[1]+...+nums[i]
+        self.total = []
+        
+        #initialize total
+        temp = 0
+        for num in nums:
+            temp += num
+            self.total.append(temp)
+        
+    def sumRange(self, i, j):
+        return self.total[j] - self.total[i-1] if i>0 else self.total[j]