代码随想录算法训练营第五十天| LeetCode123. 买卖股票的最佳时机III、122.买卖股票的最佳时机IV

一、LeetCode123. 买卖股票的最佳时机III

题目链接/代码讲解/视频讲解：https://programmercarl.com/0123.%E4%B9%B0%E5%8D%96%E8%82%A1%E7%A5%A8%E7%9A%84%E6%9C%80%E4%BD%B3%E6%97%B6%E6%9C%BAIII.html

状态：已解决

1.思路 

        这个题跟122的区别主要是买卖次数的变化，从只能买卖一次变成了买卖两次。而我们知道，在122题中，是每天都定义了持有股票和不持有股票两个状态的，因为只有一支股。那么，现在变成两支股了，我们就需要定义四个状态：持有第一支股、不持有第一支股、持有第二支股、不持有第二支股。

 （1）确定dp数组以及下标含义：

        根据刚刚的分析和121、122两题的铺垫，dp数组应该定义为一个二维数组：第一个维度表示第 i 天，第二个维度代表两支股票的状态：

        dp[i][0]：第 i 天不持有第一支股票。

        dp[i][1]：第 i 天持有第一支股票。

        dp[i][2]：第 i 天不持有第二支股票（注意不持有第二支股票代表第一支股票已经交易完）。

        dp[i][3]：第 i 天持有第二支股票（注意持有第二支股票代表第一支股票已经交易完）。

        注意：这里有个先后顺序，先是dp[i][1]，再是dp[i][0]，再是dp[i][3]，最后是dp[i][2]（对应先买入第一支股票，然后卖出第一支股票，再买入第二支股票，最后卖出第二支股票）

（2）确定递推公式：

        对于dp[i][j]（j = 0,1,2,3），有两个来源：保持前一天的股票状态或在前一天的基础上对股票进行买卖操作。故： 

        dp[i][0] = max(dp[i-1][0], dp[i-1][1] + price[i])。（要么一直没有第一支股票，要么第 i 天卖出）

        dp[i][1] = max(dp[i-1][1], dp[i-1][0] - price[i])。（要么一直持有第一支股票，要么第 i 天买入）

        dp[i][2] = max(dp[i-1][2], dp[i-1][3] + price[i])。（要么一直没有第二支股票，要么第 i 天卖出）

        dp[i][3] = max(dp[i-1][3], dp[i-1][0] - price[i])。（要么一直持有第二支股票，要么第 i 天买入，注意，由于每支股票只能交易一次，故第 i 天买入第二支股票时，一定是从不持有第一支股票的状态来的）。

（3）dp数组初始化：

        根据递推公式，可以确定第 i 个状态是由第 i - 1个状态推出的，因此dp[0][j]一定是要初始化的。

        dp[0][0] = 0。（没有开始买卖）

        dp[0][1] = -price[0]。 （买入第一支股票）

        dp[0][2] = 0。（第一支股票当天买卖结束，所得金额仍为0）

        dp[0][3] = -price[0]。（买入第二支股票）

        其余均初始化为0（总要被初始化）。

（4）确定遍历顺序：

        根据递推公式可以知道需要从前往后推导dp数组，所以遍历顺序就是从前往后。 

（5）举例推导dp数组：

        以输入[1,2,3,4,5]为例：

        大家可以看到红色框为最后两次卖出的状态。现在最大的时候一定是卖出的状态，而两次卖出的状态现金最大一定是最后一次卖出。如果想不明白的录友也可以这么理解：如果第一次卖出已经是最大值了，那么我们可以在当天立刻买入再立刻卖出。所以dp[4][4]已经包含了dp[4][2]的情况。也就是说第二次卖出手里所剩的钱一定是最多的。

        故所以最终最大利润是dp[price.size() - 1][3]

2.代码实现 

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        vector<vector<int>> dp(prices.size(),vector<int>(4,0));
        if(prices.size() == 0) return 0;
        dp[0][0] = 0;
        dp[0][1] = -prices[0];
        dp[0][2] = 0;
        dp[0][3] = -prices[0];
        for(int i=1;i<prices.size();i++){
            dp[i][0] = max(dp[i-1][0], dp[i-1][1] + prices[i]);
            dp[i][1] = max(dp[i-1][1], - prices[i]);
            dp[i][2] = max(dp[i-1][2], dp[i-1][3] + prices[i]);
            dp[i][3] = max(dp[i-1][3], dp[i-1][0] - prices[i]);
        }
        for(int i=0;i<prices.size();i++){
            cout<<dp[i][0]<<" "<<dp[i][1]<<" "<<dp[i][2]<<" "<<dp[i][3]<<endl;
        }
        return dp[prices.size()-1][2];
    }
};

时间复杂度：O(n)

空间复杂度：O(n)

二、188.买卖股票的最佳时机IV

题目链接/代码讲解/视频讲解：https://programmercarl.com/0188.%E4%B9%B0%E5%8D%96%E8%82%A1%E7%A5%A8%E7%9A%84%E6%9C%80%E4%BD%B3%E6%97%B6%E6%9C%BAIV.html

状态：已解决

1.思路 

        要解决这道题，我们先来看看123题的状态压缩解法。

        我们知道在123题中，第二支的持有状态是由第一个状态的未持有状态买入第二支股票而来，而第二支的未持有状态是由第二个状态的持有状态卖掉第二支股票而来。那么，第二支的每个状态要么跟第一支状态有关，要么跟已经推导出来的这支股票的持有状态而来。

        那么，其实我们可以不需要天数这个维度，直接只使用股票的信息来定义dp数组，然后根据这个dp数组推导这层状态。

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        vector<vector<int>> dp(2,vector<int>(2,0));
        dp[0][1] = -prices[0];
        dp[1][1] = -prices[0];
        for(int i=1;i<prices.size();i++){
            dp[0][1] = max(dp[0][1],- prices[i]);//第i天结束已持有第一支股票
            dp[0][0] = max(dp[0][0],dp[0][1] + prices[i]);//第i天结束不持有第一支股票
            dp[1][1] = max(dp[1][1],dp[0][0] - prices[i]);//第i天结束已持有第二支股票
            dp[1][0] = max(dp[1][0],dp[1][1] + prices[i]);//第i天结束不持有第二支股票
        }
        return dp[1][0];
    }
};

        那么，此题由于股票数量不是给定值，不可能在写代码时就决定状态数（也就是不能像之前用dp[i][0]、dp[i][1]、dp[i][2]、dp[i][2] 表示两支股票的所有情况），除非使用三维数组，定义dp[i][j][l]（i是天数，j是股票数，l是股票的两种状态），或者根据k将第二维开成k*2的大小。但是这样空间复杂度和较高，我们可以根据刚刚状态压缩的思路来解决这个问题。

 （1）确定dp数组以及下标含义：

        使用状态压缩，dp数组应该定义为一个二维数组dp[j][0]、dp[j][1]：第一个维度表示第 j 支股票 ，第二个维度代表每支股票持有、未持有的两个状态：

        dp[j][0]：已买入第 j 支股票。

        dp[j][1]：未持有第 j 支股票（特指买入后卖出，如果是一开始就没买入第 j 支股票，那对应的应该是刚卖出第 j-1支股票的状态，即dp[j-1][0]）。

（2）确定递推公式：

     外层是遍历天数，那么第 i 天的各支股票状态：

     ① dp[j][0] = max(dp[j][0] (第 i - 1天未持有)，dp[j-1][1] + prices[i] (第 i - 1天持有但第 i 天把它卖了)）

     ② dp[j][1] = max(dp[j][1] (第 i-1天持有且第 i 天未卖出，dp[j-1][0] - prices[i] (第 i-1天不持有但第 i 天购入了))。

（3）dp数组初始化：

       根据之前的分析，第一天持有任何股票得到的总金额都为：-prices[0]，第一天不持有任何股票得到的总金额都为：0。

（4）确定遍历顺序：

        根据状态压缩的特性我们知道外层需要遍历天数，内层需要遍历每个股票，依次计算每一天各股票的状态。 

（5）举例推导dp数组：

        以输入[1,2,3,4,5]，k=2为例。

        最终最大利润为所有股票卖出状态：dp[k][0]。

2.代码实现 

class Solution {
public:
    int maxProfit(int k, vector<int>& prices) {
        vector<vector<int>> dp(k+1,vector<int>(2,0));
        if(prices.size() == 0) return 0;
        for(int j=1;j<=k;j++){
            dp[j][1] = -prices[0];
        }
        for(int i=1;i<prices.size();i++){
            for(int j=1;j<=k;j++){
                dp[j][0] = max(dp[j][0],dp[j][1]+prices[i]);
                dp[j][1] = max(dp[j][1],dp[j-1][0]-prices[i]);
                cout<<dp[j][0]<<" "<<dp[j][1]<<endl;
            }
        }
        return dp[k][0];
    }
};

时间复杂度：O(n*k)，n为天数总数，k为股票总数

空间复杂度：O(2*k)，可以看出状态压缩得到的空间复杂度较小。