「动态规划」买卖股票的最佳时机，如何处理多笔交易？

本文链接：https://blog.csdn.net/xiang_bolin/article/details/139684583

188. 买卖股票的最佳时机 IVhttps://leetcode.cn/problems/best-time-to-buy-and-sell-stock-iv/description/

给你一个整数数组prices和一个整数k，其中prices[i]是某支给定的股票在第i天的价格。设计一个算法来计算你所能获取的最大利润。你最多可以完成k笔交易。也就是说，你最多可以买k次，卖k次。注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

输入：k = 2，prices = [2,4,1]，输出：2，解释：在第1天（股票价格 = 2）的时候买入，在第2天（股票价格 = 4）的时候卖出，这笔交易所能获得利润 = 4 - 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。

我们用动态规划的思想来解决这个问题。

确定状态表示：根据经验和题目要求，我们把状态细分为：

我们用f[i][j]表示：在第i天结束时，处于买入状态下，总共交易j次，此时的最大利润。
我们用g[i][j]表示：在第i天结束时，处于卖出状态下，总共交易j次，此时的最大利润。

解释一下上面出现的名词。如果我们手里有股票，我们称当前处于买入状态下；如果我们手里没有股票，我们称当前处于卖出状态下。一次完整的买入持有到卖出称为一笔交易，也就是说，一开始的交易次数为0，在每次卖出时交易次数加1。每次买入股票会让利润减少股票在当天的价格，卖出股票会让利润增加股票在当天的价格。在状态表示中，f和g分别表示买入和卖出状态，i表示天数，j表示交易次数，f[i][j]和g[i][j]表示最大利润。

推导状态转移方程：我们需要考虑最近的一步，即第i - 1天的状态和交易次数。

首先考虑f[i][j]，即在第i天结束时处于买入状态下，且交易了j次。

如果在第i - 1天结束时，处于买入状态下，且交易了j次，此时的利润是f[i - 1][j]，那么只需要在第i天什么都不做，在第i天结束时，依然处于买入状态下，且交易了j次，利润不变，依然是f[i - 1][j]。
如果在第i - 1天结束时，处于卖出状态下，且交易了j次，此时的利润是g[i - 1][j]，那么只需要在第i天买入股票，在第i天结束时，就会处于买入状态下，且交易了j次，利润减少股票在第i天的价格，即g[i - 1][j] - prices[i]。

由于f[i][j]表示最大利润，所以取上面2种情况的较大值，即f[i][j] = max(f[i - 1][j], g[i - 1][j] - prices[i])。

接着考虑g[i][j]，即在第i天结束时处于卖出状态下，且交易了j次。

如果在第i - 1天结束时，处于买入状态下，且交易了j - 1次，此时的利润是f[i - 1][j - 1]，那么只需要在第i天卖出股票，在第i天结束时，就会处于卖出状态下，交易次数加1，即交易了j次，利润增加股票在第i天的价格，即f[i - 1][j - 1] + prices[i]。
如果在第i - 1天结束时，处于卖出状态下，且交易了j次，此时的利润是g[i - 1][j]，那么只需要在第i天什么都不做，在第i天结束时，依然处于卖出状态下，且交易了j次，利润不变，依然是g[i - 1][j]。

由于g[i][j]表示最大利润，所以取上面2种情况的较大值，即g[i][j] = max(f[i - 1][j - 1] + prices[i], g[i - 1][j])。

综上所述：f[i][j] = max(f[i - 1][j], g[i - 1][j] - prices[i])，g[i][j] = max(f[i - 1][j - 1] + prices[i], g[i - 1][j])。

初始化：根据状态转移方程，

计算f[i][j]时，当i = 0时会越界。
计算g[i][j]时，当i = 0或j = 0时会越界。

所以，我们要初始化相应的位置。容易想到：

f[0][0]表示在第0天结束时，处于买入状态下，此时的最大利润。一开始利润是0，在第0天买入股票，显然f[0][0] = -prices[0]。
g[0][0]表示在第0天结束时，处于卖出状态下，此时的最大利润。一开始利润是0，在第0天什么都不做，显然g[0][0] = 0。

接着考虑f[0][j]，其中j > 0。j > 0说明交易次数至少是1次，也就是说在第0天一定做出了买入并且立刻卖出股票的操作。然而这种操作是没有意义的，因为浪费了交易次数，并不会增加最大利润。观察状态转移方程，发现不管是f[i][j]还是g[i][j]，最终都是对2个值求max。要想不影响到计算结果，我们要对f[0][j]，其中j > 0的位置的值都初始化为-∞。同理g[0][j]，其中j > 0的位置的值也要初始化为-∞。考虑到状态转移方程中，有g[i - 1][j] - prices[i]这样有溢出风险的计算，所以不能简单地用INT_MIN表示-∞，而要用-0x3f3f3f3f。

再考虑g[i][0]，其中i > 0。观察状态转移方程：g[i][j] = max(f[i - 1][j - 1] + prices[i], g[i - 1][j])。为什么g[i][0]，其中i > 0的位置会越界呢？因为方程中含有f[i - 1][j - 1]，当j = 0时，j - 1 = -1，不存在交易次数为-1的情况。所以，我们需要判断一下，当j - 1 = -1时，这种情况不存在，相当于求max的2项中，前一项不存在，那么就只剩下后一项，即g[i - 1][j]，即此时g[i][j] = g[i - 1][j]。只有当j - 1 >= 0时，求max的2项都有意义，此时才计算g[i][j] = max(f[i - 1][j - 1] + prices[i], g[i - 1][j])。也就是说，先让g[i][j] = g[i - 1][j]，接着判断j - 1是否大于-1，即j是否大于0，如果判断成立，再让g[i][j] = max(g[i][j], f[i - 1][j - 1] + prices[i])。

综上所述：初始化需要注意以下几点：f[0][0] = -prices[0]；g[0][0] = 0；f[0][j] = g[0][j] = -0x3f3f3f3f，其中j > 0；当i > 0时，先让g[i][j] = g[i - 1][j]，接着判断j - 1是否大于-1，即j是否大于0，如果判断成立，再让g[i][j] = max(g[i][j], f[i - 1][j - 1] + prices[i])。只需做到以上几点，就不会越界。

填表顺序：观察状态转移方程，显然我们要沿着i和j增大的方向同时填f表和g表。

返回值：假设总共有n天，最多完成k笔交易。对于第i天，i的范围是[0, n - 1]。根据题目要求，我们要返回的是最后一天结束后的最大利润，即第n - 1天结束后的最大利润。可以确定，如果要求最大利润，第n - 1天结束后一定要处于卖出状态下，否则在第n - 1天卖出股票可以获得更多利润。另外，并不确定第n - 1天结束后的交易次数。根据状态表示，我们要返回的是g[n - 1][j]的最大值，其中j的范围是[0, k]。

细节问题：由于i的范围是[0, n - 1]，j的范围是[0, k]，所以f表和g表的规模都是n x (k + 1)。另外，交易次数不会超过天数的一半，所以要先计算k = min(k, n / 2)。

class Solution {
public:
    int maxProfit(int k, vector<int>& prices) {
        const int INF = 0x3f3f3f3f;
        int n = prices.size();

        // 交易次数不会超过天数的一半
        k = min(k, n / 2);

        // 创建dp表
        vector<vector<int>> f(n, vector<int>(k + 1, -INF));
        auto g = f;

        // 初始化
        f[0][0] = -prices[0];
        g[0][0] = 0;

        // 填表
        for (int i = 1; i < n; i++) {
            for (int j = 0; j <= k; j++) {
                f[i][j] = max(f[i - 1][j], g[i - 1][j] - prices[i]);
                g[i][j] = g[i - 1][j];
                if (j > 0) {
                    g[i][j] = max(g[i][j], f[i - 1][j - 1] + prices[i]);
                }
            }
        }

        // 返回结果
        return *max_element(g[n - 1].begin(), g[n - 1].end());
    }
};

123. 买卖股票的最佳时机 IIIhttps://leetcode.cn/problems/best-time-to-buy-and-sell-stock-iii/

给定一个数组，它的第i个元素是一支给定的股票在第i天的价格。设计一个算法来计算你所能获取的最大利润。你最多可以完成两笔交易。注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

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

提示：1 <= prices.length <= 10^5，0 <= prices[i] <= 10^5。

这道题是上道题在k = 2时的特殊情况，我们只需要复用上道题的代码就行了。当然，感兴趣的话，你也可以用动态规划的思想来分析分析。

class Solution {
public:
    int maxProfit(vector<int>& prices) { return maxProfit(2, prices); }

private:
    int maxProfit(int k, vector<int>& prices) {
        const int INF = 0x3f3f3f3f;
        int n = prices.size();

        // 交易次数不会超过天数的一半
        k = min(k, n / 2);

        // 创建dp表
        vector<vector<int>> f(n, vector<int>(k + 1, -INF));
        auto g = f;

        // 初始化
        f[0][0] = -prices[0];
        g[0][0] = 0;

        // 填表
        for (int i = 1; i < n; i++) {
            for (int j = 0; j <= k; j++) {
                f[i][j] = max(f[i - 1][j], g[i - 1][j] - prices[i]);
                g[i][j] = g[i - 1][j];
                if (j > 0) {
                    g[i][j] = max(g[i][j], f[i - 1][j - 1] + prices[i]);
                }
            }
        }

        // 返回结果
        return *max_element(g[n - 1].begin(), g[n - 1].end());
    }
};