代码随想录刷题笔记 Day 54 | 买卖股票的最佳时机 III NO.123 | 买卖股票的最佳时机 IV No.188

Day 54

01. 买卖股票的最佳时机 III（NO. 123）

题目链接

代码随想录题解

<1> 题目

给定一个数组，它的第 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 <= 105
• 0 <= prices[i] <= 105

<2> 笔记

相比于之前的 I 版本和 II 版本，本题的情况就多了起来，因为可以买卖一次 或者 两次。

但其实其 状态 还是不变的，即 在某种情况下通过买卖股票获得的金钱的最大值。

与前面的买入或者卖出状态不同，本题有四种状态：第一次买入、第一次卖出、第二次买入 和 第二次卖出。

这样就可以将买卖的次数限制在 两次 了；其实有了上面的思路，递推公式的推导是很简单的，只是要注意，上面说的状态指的不是在 这一天 转变为了该状态，而是说在这一天 处于 该状态，即可能是保持前一天的状态。

现在来声明一个 dp 数组，行数为prices.length，列 0 1 2 3 分别代表一下的情况

第一次买入的情况：

• 是今天买入的：-prices[i]
• 是昨天买入的：dp[i - 1][0]

第一次卖出的情况

• 是今天卖出的，第一次卖出只能在第一次买入的情况下推导，即：dp[i - 1][0] + prices[i]
• 是昨天卖出的：dp[i - 1][1]

第二次买入的情况

• 同样，第二次买入是建立在第一次卖出的情况的：dp[i - 1][1] - prices[i]
• 是昨天买入的：dp[i - 1][2]

第二次卖出的情况

• 建立在第二次买入的基础上：dp[i - 1][2] + prices[i]
• 是昨天卖出的：dp[i - 1][3]

以上的四种情况，对每个分支求一个最大值，就是今天的这个状态的最优解。

现在来考虑初始化，对于第一天买入还是好考虑的，即初始化为 -prices[0]，第一天卖出即为 0，同样，第二天卖出也为 0

现在要考虑的就是第二天买入，对于第一天来说，第二次买入是不存在的情况，在第二天的时候这个列才是有意义的，但它能被初始化为 0 吗 ？看一下第二次买入的公式，如果说第二次卖出被初始化为 0，那从第二天开始得到的结果就是错误的，第二天原本应该是 -prices[1]，但此时变成了 0。

所以对于这种情况，应该初始化为 Integer.MIN_VALUE 来避免它不会干扰后续的计算。

其实按照这种考虑来说，第一天卖出和第二次卖出也应该初始化这个值，但是因为这两个都是卖出的情况，所得的结果都是大于等于 0 的，所以初始化成 0 不会对其产生影响。

<3> 代码

class Solution {
    public int maxProfit(int[] prices) {
        int[][] dp = new int[prices.length][4];
        dp[0][0] = -prices[0]; // 第一次持有股票
        dp[0][2] = Integer.MIN_VALUE; // 第二次持有股票
        for (int i = 1; i < prices.length; i++) {
            dp[i][0] = Math.max(-prices[i], dp[i - 1][0]); // 第一次持有股票
            dp[i][1] = Math.max(dp[i - 1][0] + 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]); // 第二次卖出股票
        }
        return Math.max(dp[prices.length - 1][1], dp[prices.length - 1][3]);
    }
}

02. 买卖股票的最佳时机 IV（No. 188）

题目链接

代码随想录题解

<1> 题目

给你一个整数数组 prices 和一个整数 k ，其中 prices[i] 是某支给定的股票在第 i 天的价格。

设计一个算法来计算你所能获取的最大利润。你最多可以完成 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 。

提示：

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

<2> 笔记

做本题之前一定要完成上一题，这样对本题的思路很有帮助。

本题在上一题的基础上，将买卖次数从 2 次拓展到了 k 次；延续上一题的思路，那无非就是每天记录 k 种状态嘛？

思路确实就是这样，但本题难的是初始化和循环控制。

上题中提到，对于第一天来说，除了第一次买入其他都是没有意义的，所以其他直接初始化为 Integer.MIN_VALUE，本题同样（但这样初始化是会出现错误的，后面再提），那对于第二天来说，只有第二次买入和第二次卖出是有意义的，其他仍然需要保持初始值；这就让我想到了滚动数组，可以避免对每行重复的初始化。

所以对于第二天来说，有意义的就是下标为 0 1 2 3 的值，对于第三天则是 0 1 2 3 4 5 这些值，所以对于第 k 天就是 0 到 2k - 1 这个范围内的下标。

对于第下标为 j 的值，是依赖于昨天的下标为 j 的值和昨天的下标为 j – 1 的值。比如，对于买入的情况：
dp[j] = Math.max(dp[j - 1] - prices[i], dp[j]);，依赖的就是昨天的第 j 次买入，或者昨天的第 j - 1 次卖出，因为每天只能持有一股股票。

对于卖出的情况也很容易写出来：dp[j] = Math.max(dp[j - 1] + prices[i], dp[j]);。

然后因为 0 - 1 没有意义，所以下标为 0 的要单独列出，所以就非常自然的写出了如下的代码

        for (int i = 1; i < prices.length; i++) {
            for (int j = 0; j < 2 * i && j < dp.length; j++) { // 同时要保证 j 不越界
                if (j == 0)  {
                    dp[0] = Math.max(-prices[i], dp[0]); // 第一次买入的情况
                } else if (j % 2 == 0) {
                    temp1 = dp[j];
                    dp[j] = Math.max(dp[j - 1] - prices[i], dp[j]); // 第 j 次买入的情况
                } else {
                    temp2 = dp[j];
                    dp[j] = Math.max(dp[j - 1] + prices[i], dp[j]);
                    res = Math.max(dp[j], res);
                }
            }
        }

但是这样有个很明显的错误，比如说在第二天，首先更新的是下标为 0 的部分，然后更新下标为 1 的部分，然而，在更新下标为 1 的部分的时候，用到了前面更新的值，导致了错误。那如何解决呢？

因为每次更新都是顺序的，在更新完 1 后面更新的一定是 2，2 后面的一定是 3，所以在每次更新之前 将本次的初始值记录下来，这样就能保证依赖的准确性。

声明两个变量 temp1 和 temp2 来分别存储，买入和卖出状态的初始值

for (int j = 0; j < 2 * i && j < dp.length; j++) {
    if (j == 0)  {
    	dp[0] = Math.max(-prices[i], dp[0]); // 第一次买入的情况
    } else if (j % 2 == 0) {
    	temp1 = dp[j];
    	dp[j] = Math.max(temp2 - prices[i], dp[j]); // 第 j 次买入的情况
    } else {
    	temp2 = dp[j];
    	dp[j] = Math.max(temp1 + prices[i], dp[j]);
    	res = Math.max(dp[j], res);
    }
}

这样就能实现存储，但需要注意的是，每一层开始都要进行初始化，否则利用的实际上是上一层最后的值：

temp1 = dp[0];

因为第一次使用的是下标为 0 的部分，所以 temp2 的值是不需要初始化的，这样就完成了递推公式的推导。

再来看初始化，直接初始化为 Integer.MIN_VALUE 是有可能引发越界的，上一题因为只初始化了第一天所以不会产生影响，而本题就不同了。所以要找一个比所有卖出状态下 dp 数组的值还要小的一个值来初始化数组。

而恰好题目中提到了，prices[i] <= 1000，那这个值就是 -1000，因为在循环过程中只能持有一张股票，所以数组的值再小也不可能小于 1000。

这样初始化也就解决了，给出代码。

<3> 代码

class Solution {
    public int maxProfit(int k, int[] prices) {
        int[] dp = new int[2 * k];
        dp[0] = -prices[0];
        int res = 0;
        for (int i = 1; i < dp.length; i++) {
            dp[i] = -1000;
        }
        int temp1 = 0;
        int temp2 = 0;
        for (int i = 1; i < prices.length; i++) {
            temp1 = dp[0];
            for (int j = 0; j < 2 * i && j < dp.length; j++) {
                if (j == 0)  {
                    dp[0] = Math.max(-prices[i], dp[0]); // 第一次买入的情况
                } else if (j % 2 == 0) {
                    temp1 = dp[j];
                    dp[j] = Math.max(temp2 - prices[i], dp[j]); // 第 j 次买入的情况
                } else {
                    temp2 = dp[j];
                    dp[j] = Math.max(temp1 + prices[i], dp[j]);
                    res = Math.max(dp[j], res);
                }
            }
        }
        return res;
    }
}