代码随想录算法训练营第五十三天_第九章_动态规划 | 123.买卖股票的最佳时机III、188.买卖股票的最佳时机IV

Jane_10358

已于 2023-04-25 12:51:01 修改

阅读量108

点赞数

文章标签：动态规划 leetcode

于 2023-01-30 09:02:04 首次发布

本文链接：https://blog.csdn.net/Jane_10358/article/details/128785967

版权

LeetCode 123.买卖股票的最佳时机III

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

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

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

视频讲解https://www.bilibili.com/video/BV1WG411K7AR 文章讲解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#%E6%80%9D%E8%B7%AF

思路：
- dp数组含义：...状态下的最大利润
  - dp[i][0]：第 i 天 结算后 从未持有股票
  - dp[i][1]：第 i 天 结算后 持有第1支股票
  - dp[i][2]：第 i 天 结算后 不持有股票（已完成1次买卖）
  - dp[i][3]：第 i 天 结算后 持有第2支股票
  - dp[i][4]：第 i 天 结算后 不持有股票（已完成2次买卖）
- 递推公式：dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - 1] -/+ prices[i])
  1. 延续前一天的状态j
  2. 由不持有状态以prices[i]买入(-) 或由持有状态以prices[i]卖出(+)
- 初始化：dp[0][奇数] = -prices[i]，其余全0
- 遍历顺序：从前向后
- ⭐最终结果在dp[prices.size() - 1][4]：首先dp[prices.size() - 1][1]和[3]相当于股票砸手里，还不如不买这支股票；其次考虑[2]和[4]，后者包含了前者（不妨设在第0天已完成一次买卖）
代码：

// 版本一
class Solution {
public:
    int maxProfit(vector<int>& prices) {
        if (prices.size() == 0) return 0;
        vector<vector<int>> dp(prices.size(), vector<int>(5, 0));
        dp[0][1] = -prices[0];
        dp[0][3] = -prices[0];
        for (int i = 1; i < prices.size(); i++) {
            dp[i][0] = dp[i - 1][0];
            dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] - prices[i]);
            dp[i][2] = max(dp[i - 1][2], dp[i - 1][1] + prices[i]);
            dp[i][3] = max(dp[i - 1][3], dp[i - 1][2] - prices[i]);
            dp[i][4] = max(dp[i - 1][4], dp[i - 1][3] + prices[i]);
        }
        return dp[prices.size() - 1][4];
    }
};
// 时间复杂度：O(n)
// 空间复杂度：O(n × 5)

// 版本二：滚动数组
class Solution {
public:
    int maxProfit(vector<int>& prices) {
        if (prices.size() == 0) return 0;
        vector<int> dp(5, 0);
        dp[1] = -prices[0];
        dp[3] = -prices[0];
        for (int i = 1; i < prices.size(); i++) {
            dp[1] = max(dp[1], dp[0] - prices[i]);
            dp[2] = max(dp[2], dp[1] + prices[i]);
            dp[3] = max(dp[3], dp[2] - prices[i]);
            dp[4] = max(dp[4], dp[3] + prices[i]);
        }
        return dp[4];
    }
};
// 时间复杂度：O(n)
// 空间复杂度：O(1)

注意：dp[2]利用的是当天的dp[1]

如果dp[1]取dp[1]，即延续持有股票的状态，那么 dp[2] = max(dp[2], dp[1] + prices[i]) 中dp[1] + prices[i] 就是今天卖出。

如果dp[1]取dp[0] - prices[i]，今天买入股票，那么 dp[2] = max(dp[2], dp[1] + prices[i]) 中的dp[1] + prices[i]相当于是今天再卖出股票，一买一卖收益为0，对所得现金没有影响。相当于今天买入股票又卖出股票，等于没有操作，保持昨天卖出股票的状态了。

// 版本三：dp[i][0]表示从未买股票，一定是0
class Solution {
public:
    int maxProfit(vector<int>& prices) {
        if (prices.size() == 0) return 0;
        vector<vector<int>> dp(prices.size(), vector<int>(5, 0));
        dp[0][1] = -prices[0];
        dp[0][3] = -prices[0];
        for (int i = 1; i < prices.size(); i++) {
            dp[i][1] = max(dp[i - 1][1], 0 - prices[i]);
            dp[i][2] = max(dp[i - 1][2], dp[i - 1][1] + prices[i]);
            dp[i][3] = max(dp[i - 1][3], dp[i - 1][2] - prices[i]);
            dp[i][4] = max(dp[i - 1][4], dp[i - 1][3] + prices[i]);
        }
        return dp[prices.size() - 1][4];
    }
};

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

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

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

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

视频讲解https://www.bilibili.com/video/BV16M411U7XJ 文章讲解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

思路：扩充上一题的dp数组即可
- dp[i][0]：第i天 结算后 不持有股票（买卖过0次）
- dp[i][1]：第i天 结算后 持有第1支股票
- dp[i][2]：第i天 结算后 不持有股票（买卖过1次）
- dp[i][3]：第i天 结算后 持有第2支股票
- dp[i][4]：第i天 结算后 不持有股票（买卖过2次）
- ...
- dp[i][2 * k - 1]：第i天 结算后 持有第k支股票
- dp[i][2 * k]：第i天 结算后 不持有股票（买卖过k次）
代码：

class Solution {
public:
    int maxProfit(int k, vector<int>& prices) {

        if (prices.size() == 0) return 0;
        vector<vector<int>> dp(prices.size(), vector<int>(2 * k + 1, 0));
        for (int j = 1; j < 2 * k; j += 2) {
            dp[0][j] = -prices[0];
        }
        for (int i = 1;i < prices.size(); i++) {
            for (int j = 0; j < 2 * k - 1; j += 2) {
                // 奇数：持有          延续前一天          由不持有状态买入
                dp[i][j + 1] = max(dp[i - 1][j + 1], dp[i - 1][j] - prices[i]);
                // 偶数：不持有        延续前一天          由持有状态卖出
                dp[i][j + 2] = max(dp[i - 1][j + 2], dp[i - 1][j + 1] + prices[i]);
            }
        }
        return dp[prices.size() - 1][2 * k];
    }
};