DAY51：动态规划（十五）买卖股票最佳时机Ⅲ+买卖股票最佳时期Ⅳ

123.买卖股票最佳时机Ⅲ（注意初始化）

• 本题需要注意DP数组初始化的问题，dp[0]实际上表示的是第一天的情况，i的含义是下标i而不是天数i！
• 直接记住这种情况下dp[0]代表的是第1天，也可以叫第0天，但是第0天是有对应的prices[0]数据的。

给定一个数组，它的第 i 个元素是一支给定的股票在第 i 天的价格。

设计一个算法来计算你所能获取的最大利润。你最多可以完成 两笔 交易。

**注意：**你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

示例 1:

输入：prices = [3,3,5,0,0,3,1,4]
输出：6
解释：在第 4 天（股票价格 = 0）的时候买入，在第 6 天（股票价格 = 3）的时候卖出，这笔交易所能获得利润 = 3-0 = 3 。
     随后，在第 7 天（股票价格 = 1）的时候买入，在第 8 天 （股票价格 = 4）的时候卖出，这笔交易所能获得利润 = 4-1 = 3 。

示例 2：

输入：prices = [1,2,3,4,5]
输出：4
解释：在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。   
     注意你不能在第 1 天和第 2 天接连购买股票，之后再将它们卖出。   
     因为这样属于同时参与了多笔交易，你必须在再次购买前出售掉之前的股票。

示例 3：

输入：prices = [7,6,4,3,1] 
输出：0 
解释：在这个情况下, 没有交易完成, 所以最大利润为 0。

示例 4：

输入：prices = [1]
输出：0

提示：

• 1 <= prices.length <= 10^5
• 0 <= prices[i] <= 10^5

思路

本题和Ⅰ与Ⅱ的区别是，买卖股票Ⅰ是只能买卖一次，买卖股票Ⅱ是可以买卖任意次。但是本题，最多买卖两次。

题目限制最多买卖两次，意味着我们必须进行状态的拆分，才能知道目前是买卖了一次还是买卖了两次，因为单从递推公式，不能得知目前的交易是第几次买卖。

DP数组含义

之前的dp数组，每一天的天数i对应的一维数组，只有0和1两个下标，也就是说每一天只有0和1两个状态。0是持有股票，1是不持有股票。

但是本题因为限制了次数，所以不止0和1两个状态，1需要分为第一次持有和第二次持有，0需要分成第一次卖出和第二次卖出。

• dp[i][0]不操作（实际上不需要这个状态，没操作手头现金一定是0）
• dp[i][1]第一次持有
• dp[i][2]第一次不持有（也就是第一次卖出）
• dp[i][3]第二次持有
• dp[i][4]第二次卖出

递推公式

dp[i][1]是第一次持有，有两个状态：

• 之前就持有了，dp[i-1][1]
• 今天刚刚买入，0-prices[i]（第一次持有一定是第一次买入，初始值0-prices[i]）

dp[i][1] = max(dp[i-1][1],-prices[i]);

dp[i][2]是第一次不持有也就是第一次卖出：

dp[i][2] = max(dp[i-1][2],dp[i-1][1]+prices[i]);//之前第一次持有状态最大现金+卖出现金

dp[i][3]是第二次持有，也就是第二次买入：

• 在第一次卖出后，也就是第一次不持有的状态基础上进行转移/累加

dp[i][3] = max(dp[i-1][3],dp[i-1][2]-prices[i]);

dp[i][4]是第二次不持有，也就是第二次卖出：

• 第二次卖出，一定是在第二次买入状态基础上进行叠加

dp[i][4] = max(dp[i-1][4],dp[i-1][3]+prices[i]);

初始化

防止数组下标越界问题，需要初始化dp[0][1]和dp[0][2]一直到dp[0][4]，代表的是下标为0天，也就是第1天，各种状态下的最大现金数。

第下标0天，实际上从天数上来说，是第1天。

//第1天第一次持有
dp[0][1] = -prices[0];
//第1天第一次不持有
dp[0][2] = -prices[0]+prices[0] = 0;
//第1天第二次持有
dp[0][3] = -prices[0];
//第1天第二次不持有
dp[0][4] = -prices[0]+prices[0] = 0;

遍历顺序

本题是在前一天状态基础上进行转移，因此是正序遍历

最开始的写法：初始化全部写成0

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        if(prices.size()==1) return 0;
        //分4种状态
        vector<vector<int>>dp(prices.size(),vector<int>(4,0));
        //初始化全部为0，不用管
        for(int i=1;i<prices.size();i++){
            //0:第一次持有
            dp[i][0] = max(dp[i-1][0],-prices[i]);
            //1：第一次不持有
            dp[i][1] = max(dp[i-1][1],dp[i-1][0]+prices[i]);
            //2:第二次持有
            dp[i][2] = max(dp[i-1][2],dp[i-1][1]-prices[i]);
            //3:第二次不持有
            dp[i][3] = max(dp[i-1][3],dp[i-1][2]+prices[i]);
        }
        //最后一定是不持有的状态取最大值
        return max(dp[prices.size()-1][1],dp[prices.size()-1][3]);
    }
};

debug测试：解答错误，第0天实际上是对应prices[0]和dp[0]

因为dp[0]在这版代码中被全部初始化为0，但是实际上dp[0]对应的是第0天！

这个问题在 198.打家劫舍 中也犯过，下标是0的时候，dp[0]含义是偷窃下标为0的房屋得到的最大金额，下标为0的房屋已经对应了一个value[0]，所以dp[0]不应该=0，应该=value[0]！

完整版

• dp[0]实际上表示的是第一天的情况！
• 第0天，有对应的prices[0]数据

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        if(prices.size()==1) return 0;
        //分4种状态
        vector<vector<int>>dp(prices.size(),vector<int>(4,0));
        //初始化：要初始化下标i=0，也就是第一天的情况
        dp[0][0] = -prices[0];
        //dp[0][1] = -prices[i]+prices[i] = 0;第0天的状态1一定是0
        dp[0][2] = -prices[0];//第0天第二次持有，一定是当天买当天卖
        for(int i=1;i<prices.size();i++){
            //0:第一次持有
            dp[i][0] = max(dp[i-1][0],-prices[i]);
            //1：第一次不持有
            dp[i][1] = max(dp[i-1][1],dp[i-1][0]+prices[i]);
            //2:第二次持有
            dp[i][2] = max(dp[i-1][2],dp[i-1][1]-prices[i]);
            //3:第二次不持有
            dp[i][3] = max(dp[i-1][3],dp[i-1][2]+prices[i]);
        }
        //最后一定是不持有的状态取最大值
        return max(dp[prices.size()-1][1],dp[prices.size()-1][3]);
    }
};

总结

• DP数组的初始化问题一定要注意，并不是所有的问题都会直接初始化为0，i代表的含义是下标i，而不是天数i，下标0的时候，实际上代表的是第一天！i的范围是[0,nums.size()-1]，dp[0]实际上代表的是第1天持有股票时手里现金的状态。
• 初始化主要是看dp[0]的时候，对应的输入数组是不是有取值（同 198.打家劫舍 系列）
• 当限制了买卖次数，我们又不能从递推公式看出本次买卖是第几次买卖的时候，就只能把每一次买卖的状态都列出来，新的一次买卖一定是在上一次买卖状态的基础上，进行状态转移！

188.买卖股票最佳时机Ⅳ

给定一个整数数组 prices ，它的第 i 个元素 prices[i] 是一支给定的股票在第 i 天的价格，和一个整型 k 。

设计一个算法来计算你所能获取的最大利润。你最多可以完成 k 笔交易。也就是说，你最多可以买 k 次，卖 k 次。

**注意：**你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

示例 1：

输入：k = 2, prices = [2,4,1]
输出：2
解释：在第 1 天 (股票价格 = 2) 的时候买入，在第 2 天 (股票价格 = 4) 的时候卖出，这笔交易所能获得利润 = 4-2 = 2 。

示例 2：

输入：k = 2, prices = [3,2,6,5,0,3]
输出：7
解释：在第 2 天 (股票价格 = 2) 的时候买入，在第 3 天 (股票价格 = 6) 的时候卖出, 这笔交易所能获得利润 = 6-2 = 4 。
     随后，在第 5 天 (股票价格 = 0) 的时候买入，在第 6 天 (股票价格 = 3) 的时候卖出, 这笔交易所能获得利润 = 3-0 = 3 。

提示：

• 0 <= k <= 100
• 0 <= prices.length <= 1000
• 0 <= prices[i] <= 1000

思路

Ⅲ是至多买卖两次，Ⅳ是至多买卖K次。

上一道题目里，我们直接将第一次持有、第一次不持有、第二次持有、第二次不持有进行了状态的拆分，把所有状态都列了出来。

我们可以发现，如果至多允许2次买卖，那么会有4种状态：

• 第1次持有
• 第1次不持有
• 第2次持有
• 第2次不持有

那么我们可以类推得到，如果允许K次买卖，那么第i天的一维数组的状态数量应该是2k种！对于每一个第K次交易，都是第K次持有或者第K次不持有的情况。

因此我们可以基于上一题的情况，将一维状态数组下标定义为1–2K，来对应这2K种状态！

在这2K种状态中，每一种状态都承接上一种状态。

DP数组含义

dp[i][j]表示下标为i天时，第j种状态下手里最大的现金数值，其中j的取值是1–2k，2k是总的状态数。

递推公式

dp[i][1]表示第1次持有股票

dp[i][1] = max(dp[i-1][1],-prices[i]);

dp[i][2]表示第1次不持有股票

dp[i][2] = max(dp[i-1][2],dp[i-1][1]+prices[i]);

dp[i][3]表示第2次持有股票

dp[i][3] = max(dp[i-1][3],dp[i-1][2]-prices[i]);

dp[i][4]表示第2次不持有股票

dp[i][4] = max(dp[i-1][4],dp[i-1][3]+prices[i]);

观察上面几个递推的例子，我们可以得出，递推应该为：

for(int j=1;j<=2k;j++){
    dp[i][j] = max(dp[i-1][j],dp[i-1][j-1]+prices[i]*(-1)^j);//但是这里^的用法是错误的，cpp的幂不是这么算的
}

CPP中求幂存在的问题

但是，这个递推公式在实际编程中可能会遇到一些问题，主要是因为在 C++ 中，(-1)^j 的结果并不是我们所期望的。在 C++ 中，^ 是按位异或运算符，它的行为和数学中的指数运算不同。

如果想要实现 (-1)^j 的效果，可以使用条件运算符（也叫三元运算符）来实现：

//改为三目运算符代替幂的操作
for (int j = 1; j <= 2 * k; j++) {
    dp[i][j] = max(dp[i-1][j], dp[i-1][j-1] + (j%2==0?prices[i]:-prices[i]));
}

初始化

介于递推公式涉及到了dp[i-1]，因此i=0的情况需要初始化。但是因为每个i的下标都是1–2k范围，因此这个范围内的所有数字都需要初始化！

下标为0，但是仍然有对应的prices[0]，也就是代表的是第一天的情况。

dp[0][1] = -prices[0];
dp[0][2] = prices[0]-prices[0] = 0;
dp[0][3] = -prices[0];
//后面都是循环
dp[0][2k] = 0;

因此，初始化写为：

for(int i=1;i<=2k;i++){
    dp[0][i] = (i%2==0)?0:-prices[0];
}

遍历顺序

后面的数值依靠前面的数值，所以是正序遍历。

最开始的写法

class Solution {
public:
    int maxProfit(int k, vector<int>& prices) {
        if(prices.size()==1) return 0;
        vector<vector<int>>dp(prices.size(),vector<int>(2*k+1,0));
        //初始化
        for(int i=1;i<=2*k;i++){
            dp[0][i]=(i%2==0)?0:-prices[0];
        }
        //递推
        for(int i=1;i<prices.size();i++){
            for(int j=1;j<=2*k;j++){
                dp[i][j]=max(dp[i-1][j],dp[i-1][j-1]+(j%2==0)?prices[i]:-prices[i]);
            }
        }
        return *max_element(dp[prices.size()-1].begin(),dp[prices.size()-1].end());
    }
};

debug测试：

• 三元运算符的优先级写错，导致了解答错误

  debug记录：三目运算符优先级的问题_大磕学家ZYX的博客-CSDN博客

• 初始化的时候应该为dp[0][i]=(i%2==0)?0:-prices[0];，写成了0:-prices[i]，也会造成解答错误，这种手误一定要避免！

  debug记录：解答错误并出现较大数字_大磕学家ZYX的博客-CSDN博客

完整版

class Solution {
public:
    int maxProfit(int k, vector<int>& prices) {
        if(prices.size()==1) return 0;
        vector<vector<int>>dp(prices.size(),vector<int>(2*k+1,0));
        //初始化
        for(int i=1;i<=2*k;i++){
            dp[0][i]=(i%2==0)?0:-prices[0];
        }
        //递推
        for(int i=1;i<prices.size();i++){
            for(int j=1;j<=2*k;j++){
                dp[i][j]=max(dp[i-1][j],dp[i-1][j-1]+(j%2==0?prices[i]:-prices[i]));
            }
        }
        return *max_element(dp[prices.size()-1].begin(),dp[prices.size()-1].end());
    }
};