【LeetCode】解题123：Best Time to Buy and Sell Stock III（动态规划）

Problem 123: Best Time to Buy and Sell Stock III [Hard]

Say you have an array for which the i^th element is the price of a given stock on day i.

Design an algorithm to find the maximum profit. You may complete at most two transactions.

Note: You may not engage in multiple transactions at the same time (i.e., you must sell the stock before you buy again).

Example 1:

Input: [3,3,5,0,0,3,1,4]
Output: 6
Explanation: Buy on day 4 (price = 0) and sell on day 6 (price = 3), profit = 3-0 = 3.
Then buy on day 7 (price = 1) and sell on day 8 (price = 4), profit = 4-1 = 3.

Example 2:

Input: [1,2,3,4,5]
Output: 4
Explanation: Buy on day 1 (price = 1) and sell on day 5 (price = 5), profit = 5-1 = 4.
Note that you cannot buy on day 1, buy on day 2 and sell them later, as you are
engaging multiple transactions at the same time. You must sell before buying again.

Example 3:

Input: [7,6,4,3,1]
Output: 0
Explanation: In this case, no transaction is done, i.e. max profit = 0.

来源：LeetCode

解题思路

本题需要使用动态规划思想。

I. O(2n)时间+O(3n)空间

最常规的DP思想是使用maxP[N][3]来存储最大利润，其中maxP[i][k]是指在第k次循环中，第i天的最大利润。k的范围由总交易次数决定，本题中能够交易两次，因此k为0~2。
每轮循环k的更新公式为：
m i n C o s t 0 = p r i c e s [ 0 ] m i n C o s t = min ⁡ { m i n C o s t , p r i c e s [ i ] − m a x P [ i − 1 ] [ k − 1 ] } m a x P [ i ] [ k ] = max ⁡ { m a x P [ i − 1 ] [ k ] , p r i c e s [ i ] − m i n C o s t } i ∈ [ 1 , N − 1 ] , k ∈ [ 1 , 2 ] minCost_0 = prices[0]\\ minCost = \min\{minCost, prices[i] - maxP[i-1][k-1]\}\\ maxP[i][k] = \max\{maxP[i-1][k], prices[i] - minCost\}\\ i\in[1,N-1], k\in[1,2] minCost0​=prices[0]minCost=min{minCost,prices[i]−maxP[i−1][k−1]}maxP[i][k]=max{maxP[i−1][k],prices[i]−minCost}i∈[1,N−1],k∈[1,2]
其中$minCost$代表当前最低成本，$prices[i]-maxP[i-1][k-1]$是当前第i天的价格减去上一轮中第i-1天的最大利润，相当于在卖出上一笔后在当天买入的实际成本：价格-利润=成本。$maxP[i][k]$是当前最大利润，$maxP[i-1][k]$是本轮中第i-1天的最大利润。
$maxP[i][0]$全为0；$maxP[i][1]$为只买卖一次的最大利润；$maxP[i][2]$为买卖两次的最大利润。
该方法需要遍历2n次，需要3n的额外空间。

II. O(2n)时间+O(n)空间

由I中的更新公式可以看出，minCost与上一轮的maxP[i-1]有关，maxP[i]只与本轮的maxP[i-1]有关，而minCost需要的上一轮的maxP[i-1]其实与使用上一轮的maxP[i]意义相同（一个是昨天卖今天买的成本，一个是今天卖今天买的成本，如果今天的prices[i]比较低，那么上一轮的maxP[i]=maxP[i-1]；如果今天的prices[i]比较高，那么今天买入一定不合算，所以minCost无论使用maxP[i]还是maxP[i-1]都不会更新），因此minCost只与上一轮的maxP[i]有关，maxP[i]只与本轮的maxP[i-1]有关，则maxP可以只使用O(n)的额外空间。
每轮循环的更新公式为：
m i n C o s t 0 = p r i c e s [ 0 ] m i n C o s t = min ⁡ { m i n C o s t , p r i c e s [ i ] − m a x P [ i ] } m a x P [ i ] = max ⁡ { m a x P [ i − 1 ] , p r i c e s [ i ] − m i n C o s t } i ∈ [ 1 , N − 1 ] minCost_0 = prices[0]\\ minCost = \min\{minCost, prices[i] - maxP[i]\}\\ maxP[i] = \max\{maxP[i-1], prices[i] - minCost\}\\ i\in[1,N-1] minCost0​=prices[0]minCost=min{minCost,prices[i]−maxP[i]}maxP[i]=max{maxP[i−1],prices[i]−minCost}i∈[1,N−1]
该方法需要遍历2n次，需要n的额外空间。

运行结果：

III. O(n)时间+O(4)空间

由II中的更新公式，minCost只与上一轮的maxP[i]有关，maxP[i]只与本轮的maxP[i-1]有关，因此maxP只需要常数空间。
而第二轮循环中，只需要用到当天和前一天的数据，因此两重循环可以合并，可以在一次循环中使用两组{minCost_k, maxP_k}，先计算第一轮的{minCost₁, maxP₁}，再计算第二轮的{minCost₂, maxP₂}。
更新公式为：
c p c p 0 = { p r i c e s [ 0 ] , 0 , p r i c e s [ 0 ] , 0 } c p c p = { min ⁡ { c p c p [ 0 ] , p r i c e s [ i ] } , max ⁡ { c p c p [ 1 ] , p r i c e s [ i ] − c p c p [ 0 ] } , min ⁡ { c p c p [ 2 ] , p r i c e s [ i ] − c p c p [ 1 ] } , max ⁡ { c p c p [ 3 ] , p r i c e s [ i ] − c p c p [ 2 ] } } cpcp_0 = \{prices[0], 0, prices[0], 0\}\\ cpcp = \{\min\{cpcp[0], prices[i]\}, \max\{cpcp[1], prices[i]-cpcp[0]\}, \\ \min\{cpcp[2], prices[i] - cpcp[1]\}, \max\{cpcp[3], prices[i] - cpcp[2]\}\} cpcp0​={prices[0],0,prices[0],0}cpcp={min{cpcp[0],prices[i]},max{cpcp[1],prices[i]−cpcp[0]},min{cpcp[2],prices[i]−cpcp[1]},max{cpcp[3],prices[i]−cpcp[2]}}
其中 c p c p = { m i n C o s t 1 , m a x P 1 , m i n C o s t 2 , m a x P 2 } cpcp = \{minCost_1, maxP_1, minCost_2, maxP_2\} cpcp={minCost1​,maxP1​,minCost2​,maxP2​}，更新过程相当于
c p c p = { m i n C o s t 1 = min ⁡ { m i n C o s t 1 , p r i c e s [ i ] } , m a x P 1 = max ⁡ { m a x P 1 , p r i c e s [ i ] − m i n C o s t 1 } , m i n C o s t 2 = min ⁡ { m i n C o s t 2 , p r i c e s [ i ] − m a x P 1 } , m a x P 2 = max ⁡ { m a x P 2 , p r i c e s [ i ] − m i n C o s t 2 } } cpcp = \{\\ minCost_1 = \min\{minCost_1,prices[i]\}, \\ maxP_1 = \max\{maxP_1,prices[i]-minCost_1\},\\ minCost_2 = \min\{minCost_2,prices[i]-maxP_1\}, \\ maxP_2 = \max\{maxP_2, prices[i]-minCost_2\}\} cpcp={minCost1​=min{minCost1​,prices[i]},maxP1​=max{maxP1​,prices[i]−minCost1​},minCost2​=min{minCost2​,prices[i]−maxP1​},maxP2​=max{maxP2​,prices[i]−minCost2​}}
该方法只需要$O(n)$时间，$O(4)$空间。

运行结果：

Solution (Java)

II. O(2n)时间+O(n)空间

class Solution {
    public int maxProfit(int[] prices) {
        int N = prices.length;
        if(N < 2) return 0;
        int minCost;
        int[] maxP = new int[N];
        for(int k = 0; k < 2; k++){
            minCost = prices[0];
            for(int i = 1; i < N; i++){
                minCost = Math.min(minCost, prices[i] - maxP[i]);
                maxP[i] = Math.max(maxP[i-1], prices[i] - minCost);
            }
        }
        return maxP[N-1];
    }
}

III. O(n)时间+O(1)空间

class Solution {
    public int maxProfit(int[] prices) {
        int N = prices.length;
        if(N < 2) return 0;
        int[] cpcp = {prices[0], 0, prices[0], 0}; //{minCost1, maxP1, minCost2, maxP2}
        for(int i = 1; i < N; i++){
            cpcp[0] = Math.min(cpcp[0], prices[i]);
            cpcp[1] = Math.max(cpcp[1], prices[i] - cpcp[0]);
            cpcp[2] = Math.min(cpcp[2], prices[i] - cpcp[1]);
            cpcp[3] = Math.max(cpcp[3], prices[i] - cpcp[2]);
        }
        return cpcp[3];
    }
}