第50天Dynamic Programming Stock 123、188

123. Best Time to Buy and Sell Stock III

• 关键在于至多买卖两次，这意味着可以买卖一次，可以买卖两次，也可以不买卖。
• 公式：
  • dp[i][0]在for loop里不需要更新，或者更新了也是dp[i-1][0] 因为没有操作
  • dp[i][2] = max(dp[i - 1][1] + prices[i], dp[i - 1][2])
    • 操作一：第i天卖出股票了，那么dp[i][2] = dp[i - 1][1] + prices[i]
    • 操作二：第i天没有操作，沿用前一天卖出股票的状态，即：dp[i][2] = dp[i - 1][2] 这里这个状态，一层层倒推回去会到初始化的dp[0][2] = 0，所以这里包含了买卖一次，或者不买卖的最优情况。
  • 同理dp[i][4] = max(dp[i - 1][3] + prices[i], dp[i - 1][4])，这里包含了买卖两次，买卖一次，或者不买卖的最优情况。
• 这也是为什么最后只需要return dp[prices.length-1][4];
• 初始化：
  • dp[0][2] = 0; 第0天做第一次卖出的操作，这个初始值应该是多少呢？首先卖出的操作一定是收获利润，整个股票买卖最差情况也就是没有盈利即全程无操作现金为0，从递推公式中可以看出每次是取最大值，那么既然是收获利润如果比0还小了就没有必要收获这个利润了。
  • dp[0][3] = -prices[0]; 第一次还没买入呢，怎么初始化第二次买入呢？第二次买入依赖于第一次卖出的状态，其实相当于第0天第一次买入了，第一次卖出了，然后在买入一次（第二次买入），那么现在手头上没有现金，只要买入，现金就做相应的减少。
• Time Complexity: O(n)
• Space Complexity: O(5*n) -> 可以优化成O(1)

// O(n)
class Solution {
    public int maxProfit(int[] prices) {
        int[][] dp = new int[prices.length][5];
        dp[0][0] = 0; // don't have stock
        dp[0][1] = -prices[0]; // have stock first time
        dp[0][2] = 0; // sell stock first time
        dp[0][3] = -prices[0]; // have stock second time
        dp[0][4] = 0; // sell stock second time

        for (int i=1; i<prices.length; i++) {
            // dp[i][0] = dp[i-1][0];
            dp[i][1] = Math.max(-prices[i], dp[i-1][1]);
            dp[i][2] = Math.max(dp[i-1][1]+prices[i], dp[i-1][2]);
            dp[i][3] = Math.max(dp[i-1][2]-prices[i], dp[i-1][3]);
            dp[i][4] = Math.max(dp[i-1][3]+prices[i], dp[i-1][4]);
        }
        return dp[prices.length-1][4];
    }
}

// O(1)
class Solution {
    public int maxProfit(int[] prices) {
        int[] dp = new int[5];
        dp[0] = 0; // don't have stock
        dp[1] = -prices[0]; // have stock first time
        dp[2] = 0; // sell stock first time
        dp[3] = -prices[0]; // have stock second time
        dp[4] = 0; // sell stock second time

        for (int i=1; i<prices.length; i++) {
            int temp = dp[1];
            dp[1] = Math.max(-prices[i], dp[1]);
            int temp2 = dp[2];
            dp[2] = Math.max(temp+prices[i], dp[2]);
            int temp3 = dp[3];
            dp[3] = Math.max(temp2-prices[i], dp[3]);
            dp[4] = Math.max(temp3+prices[i], dp[4]);
        }
        return dp[4];
    }
}

• Space Complexity优化甚至可以写成更干净的版本【不需要】
  • dp[2]利用的是当天的dp[1](第一次买入的状态) dp[1] = max(dp[1], dp[0] - prices[i]);
  • 1. 如果dp[1]取dp[1]，即保持买入股票的状态，那么 dp[2] = max(dp[2], dp[1] + prices[i]);中dp[1] + prices[i] 就是今天卖出。
  • 2. 如果dp[1]取dp[0] - prices[i]，今天买入股票，那么dp[2] = max(dp[2], dp[1] + prices[i]);中的dp[1] + prices[i]相当于是在再卖出股票，一买一卖收益为0，对所得现金没有影响。相当于今天买入股票又卖出股票，等于没有操作，保持昨天卖出股票的状态了。

class Solution {
    public int maxProfit(int[] prices) {
        int[] dp = new int[5];
        dp[0] = 0; // don't have stock
        dp[1] = -prices[0]; // have stock first time
        dp[2] = 0; // sell stock first time
        dp[3] = -prices[0]; // have stock second time
        dp[4] = 0; // sell stock second time

        for (int i=1; i<prices.length; i++) {
            dp[1] = Math.max(-prices[i], dp[1]);
            dp[2] = Math.max(dp[1]+prices[i], dp[2]);
            dp[3] = Math.max(dp[2]-prices[i], dp[3]);
            dp[4] = Math.max(dp[3]+prices[i], dp[4]);
        }
        return dp[4];
    }
}