finish Buy and Sell Stock questions

Author: selfboot

BitManipulation/137_SingleNumberII.cpp

@@ -0,0 +1,55 @@
+/*
+ * @Author: [email protected]
+ * @Last Modified time: 2016-08-23 09:54:56
+ */
+
+class Solution {
+public:
+    /*
+    If you sum the ith bit of all numbers and mod 3,
+    it must be either 0 or 1 due to the constraint of this problem
+    where each number must appear either three times or once.
+    This will be the ith bit of that "single number".
+    */
+    int singleNumber(vector<int>& nums) {
+        int bits[32]={0};
+        int ret = 0;
+        for(int i=0; i<32; i++){
+            for(auto n: nums){
+                bits[i] += (n >> i) & 0x1;
+            }
+            bits[i] %= 3;
+            ret |= bits[i] << i;
+        }
+        return ret;
+    }
+};
+
+class Solution_2 {
+public:
+    /*
+    Use two-bits represents the sum(should be 0/3, 1, 2) of all num's i-th bit.
+    Twice-Once(the two bits): 00(0, 3)-->01(1)-->10(2)-->00(0, 3)
+    Then we need to set rules for 'once' and 'twice' so that they act as we hopes.
+        once = once ^ n & (~twice)
+        twice = twice ^ n & (~once)
+
+    Since each of the 32 bits follow the same rules,
+    we can calculate them all at once.
+    */
+    int singleNumber(vector<int>& nums) {
+        int once=0, twice=0;
+        for(auto n: nums){
+            once = (once ^ n) & (~twice);
+            twice = (twice ^ n) & (~once);
+        }
+        return once;
+    }
+};
+
+/*
+[1]
+[1,1,3,1]
+[1,1,1,2,2,2,3,4,4,4]
+[-2,-2,1,1,-3,1,-3,-3,-4,-2]
+*/

BitManipulation/137_SingleNumberII.py

@@ -1,23 +1,56 @@
 #! /usr/bin/env python
 # -*- coding: utf-8 -*-
-# Refer to https://leetcode.com/discuss/857/constant-space-solution
+# @Author: [email protected]
+# @Last Modified time: 2016-08-23 09:44:33
 
 
 class Solution(object):
+    """
+    If you sum the ith bit of all numbers and mod 3,
+    it must be either 0 or 1 due to the constraint of this problem
+    where each number must appear either three times or once.
+    This will be the ith bit of that "single number".
+
+    Refer to:
+    https://discuss.leetcode.com/topic/455/constant-space-solution
+    """
     def singleNumber(self, nums):
-        once = 0
-        twice = 0
-        third = 0
-        for num in nums:
-            twice |= once & num
-            once ^= num
-            third = once & twice
-            once &= ~third
-            twice &= ~third
+        bit_record = [0] * 32
+        result = 0
+        for i in range(32):
+            for n in nums:
+                bit_record[i] += (n >> i) & 0x1
+            bit_val = bit_record[i] % 3
+            result |= bit_val << i
+
+        # Int in python is an object and has no upper limit,
+        # If you do 1<<31, you get 2147483648 other than -2147483648
+        return result - 2**32 if result >= 2**31 else result
+
 
+class Solution_2(object):
+    """
+    Use two-bits represents the sum(should be 0/3, 1, 2) of all num's i-th bit.
+    Twice-Once(the two bits): 00(0, 3)-->01(1)-->10(2)-->00(0, 3)
+    Then we need to set rules for 'once' and 'twice' so that they act as we hopes.
+        once = once ^ n & (~twice)
+        twice = twice ^ n & (~once)
+
+    Since each of the 32 bits follow the same rules,
+    we can calculate them all at once.  Refer to:
+    https://discuss.leetcode.com/topic/2031/challenge-me-thx/17
+    """
+    def singleNumber(self, nums):
+        once, twice = 0, 0
+        for n in nums:
+            once = once ^ n & (~twice)
+            twice = twice ^ n & (~once)
         return once
 
+
 """
 [1]
+[1,1,3,1]
 [1,1,1,2,2,2,3,4,4,4]
+[-2,-2,1,1,-3,1,-3,-3,-4,-2]
 """

DynamicProgramming/121_BestTimeToBuyAndSellStock.cpp

@@ -0,0 +1,53 @@
+/*
+ * @Author: [email protected]
+ * @Last Modified time: 2016-08-23 11:57:19
+ */
+
+class Solution {
+public:
+    /*
+    Same as "max subarray problem" using Kadane's Algorithm
+
+    Just need one scan through the array values,
+    computing at each position the max profit ending at that position.
+
+    https://en.wikipedia.org/wiki/Maximum_subarray_problem
+    */
+    int maxProfit(vector<int>& prices) {
+        if(prices.size() == 0)  return 0;
+        int min_buy = prices[0], max_pro = 0;
+        for(int i=1; i<prices.size(); i++){
+            int cur_price = prices[i];
+            min_buy = (min_buy <= cur_price ? min_buy : cur_price);
+            max_pro = (max_pro >= cur_price - min_buy ? max_pro :cur_price-min_buy);
+        }
+        return max_pro;
+    }
+};
+
+class Solution_2{
+public:
+    /*
+    sell_1: The maximum if we've just sold 1nd stock so far.
+    buy_1: The maximum if we've just buy 1st stock so far.
+
+    Then we can update sell_1 if p + buy_1(sell now) get more than pre-sell_1.
+    And update buy_1 if remain more money when we buy now than pre-buy_1.
+    Here update sell_1 before buy_1 because we need to use pre_buy_1 to get sell_1.
+    */
+    int maxProfit(vector<int>& prices) {
+        int sell_1 = 0, buy_1 = INT_MIN;
+        for(int p: prices){
+            sell_1 = max(sell_1, p+buy_1);
+            buy_1 = max(buy_1, -p);
+        }
+        return sell_1;
+    }
+};
+
+/*
+[]
+[3,4,5,6,2,4]
+[6,5,4,3,2,1]
+[1,2,3,4,3,2,1,9,11,2,20]
+*/

DynamicProgramming/121_BestTimeToBuyAndSellStock.py

@@ -1,49 +1,40 @@
 #! /usr/bin/env python
 # -*- coding: utf-8 -*-
-# According to: http://liangjiabin.com/blog/2015/04/leetcode-best-time-to-buy-and-sell-stock.html
 
 
 class Solution(object):
+    """ Same as "max subarray problem" using Kadane's Algorithm.
+
+    Just need one scan through the array values,
+    computing at each position the max profit ending at that position.
+    https://en.wikipedia.org/wiki/Maximum_subarray_problem
+    """
     def maxProfit(self, prices):
         if not prices:
             return 0
         max_profit = 0
         min_buy = prices[0]
         for price in prices:
             min_buy = min(price, min_buy)
-            max_profit = max(price-min_buy, max_profit)
+            max_profit = max(price - min_buy, max_profit)
         return max_profit
-"""
-# Not readable.
-class Solution(object):
-    def maxProfit(self, prices):
-        if not prices:
-            return 0
-        buy_price = prices[0]
-        sell_price = buy_price
-        max_profit = 0
-        days = len(prices)
-        ith_day = 1
-        while ith_day < days:
-            # The current price is higher than the cost we buy,
-            # so just keep the stock, until the price is lower.
-            if prices[ith_day] >= buy_price:
-                # make the price that we sell the stock be biggest
-                if prices[ith_day] > sell_price:
-                    sell_price = prices[ith_day]
-                else:
-                    pass
-            # Meet a new lower price, so buy the stock
-            else:
-                max_profit = max(max_profit, sell_price - buy_price)
-                buy_price = prices[ith_day]
-                sell_price = buy_price
 
-            ith_day += 1
-        # The price may never be lower than the first day.
-        max_profit = max(max_profit, sell_price - buy_price)
-        return max_profit
-"""
+
+class Solution_2(object):
+    """
+    sell_1: The maximum if we've just sold 1nd stock so far.
+    buy_1: The maximum if we've just buy 1st stock so far.
+
+    Then we can update sell_1 if p + buy_1(sell now) get more than pre-sell_1.
+    And update buy_1 if remain more money when we buy now than pre-buy_1.
+    Here update sell_1 before buy_1 because we need to use pre_buy_1 to get sell_1.
+    """
+    def maxProfit(self, prices):
+        sell_1, buy_1 = 0, -2**31
+        for p in prices:
+            sell_1 = max(sell_1, p + buy_1)
+            buy_1 = max(buy_1, -p)
+        return sell_1
 
 """
 []

DynamicProgramming/123_BestTimeToBuyAndSellStockIII.cpp

@@ -1,9 +1,8 @@
 /*
-* @Author: xuelangZF
-* @Date:   2016-03-09 14:10:44
-* @Last Modified by:   xuelangZF
-* @Last Modified time: 2016-03-09 14:10:44
-*/
+ * @Author: [email protected]
+ * @Last Modified time: 2016-08-23 10:53:01
+ */
+
 class Solution {
 public:
     int maxProfit(vector<int>& prices) {
@@ -33,3 +32,37 @@ class Solution {
         return max_profit;
     }
 };
+
+class Solution_2 {
+public:
+    /*
+    Assume we only have 0 money at first, Then
+    sell_2: The maximum if we've just sold 2nd stock so far.
+    buy_2: The maximum if we've just buy 2nd stock so far.
+    sell_1: The maximum if we've just sold 1nd stock so far.
+    buy_1: The maximum if we've just buy 1st stock so far.
+    Refer to:
+    https://discuss.leetcode.com/topic/5934/is-it-best-solution-with-o-n-o-1
+    */
+    int maxProfit(vector<int>& prices) {
+        int buy_1 = INT_MIN, buy_2 = INT_MIN;
+        int sell_1 = 0, sell_2 = 0;
+        for(int p: prices){
+            sell_2 = max(sell_2, p+buy_2);
+            buy_2 = max(buy_2, sell_1-p);
+            sell_1 = max(sell_1, p+buy_1);
+            buy_1 = max(buy_1, -p);
+        }
+        return sell_2;
+    }
+};
+
+/*
+[]
+[1,2]
+[1,3,5]
+[2,8,3,9]
+[2,8,3,9,1,2]
+[2,8,3,9,1,9]
+[6,5,4,3,2,1]
+*/

DynamicProgramming/123_BestTimeToBuyAndSellStockIII.py

@@ -1,15 +1,9 @@
 #! /usr/bin/env python
 # -*- coding: utf-8 -*-
-# According to:
-# http://liangjiabin.com/blog/2015/04/leetcode-best-time-to-buy-and-sell-stock.html
 
 
 class Solution(object):
     def maxProfit(self, prices):
-        """
-        :type prices: List[int]
-        :rtype: int
-        """
         if not prices:
             return 0
         days_count = len(prices)
@@ -20,13 +14,13 @@ def maxProfit(self, prices):
         min_buy = prices[0]
         for i in range(1, days_count):
             min_buy = min(min_buy, prices[i])
-            pre_profit[i] = max(pre_profit[i-1], prices[i]-min_buy)
+            pre_profit[i] = max(pre_profit[i - 1], prices[i] - min_buy)
 
         # Get max profit when buy and sell Stock only once in post (n-i) days.
         max_sell = prices[-1]
-        for j in range(days_count-2, -1, -1):
+        for j in range(days_count - 2, -1, -1):
             max_sell = max(max_sell, prices[j])
-            post_profit[j] = max(post_profit[j+1], max_sell-prices[j])
+            post_profit[j] = max(post_profit[j + 1], max_sell - prices[j])
 
         # Find the max profit when buy and sell Stock only twice.
         # First in the pre kth day, and second in the post (n-k) days
@@ -35,6 +29,28 @@ def maxProfit(self, prices):
             max_profit = max(max_profit, pre_profit[i] + post_profit[i])
         return max_profit
 
+
+class Solution_2(object):
+    """
+    Assume we only have 0 money at first, Then
+    sell_2: The maximum if we've just sold 2nd stock so far.
+    buy_2: The maximum if we've just buy 2nd stock so far.
+    sell_1: The maximum if we've just sold 1nd stock so far.
+    buy_1: The maximum if we've just buy 1st stock so far.
+
+    Refer to:
+    https://discuss.leetcode.com/topic/5934/is-it-best-solution-with-o-n-o-1
+    """
+    def maxProfit(self, prices):
+        buy_1, buy_2 = -2**31, -2**31
+        sell_1, sell_2 = 0, 0
+        for p in prices:
+            sell_2 = max(sell_2, p + buy_2)
+            buy_2 = max(buy_2, sell_1 - p)
+            sell_1 = max(sell_1, p + buy_1)
+            buy_1 = max(buy_1, -p)
+        return sell_2
+
 """
 []
 [1,2]