代码随想录Day 42|leetcode题目：188.买卖股票的最佳时机IV、309.最佳买卖股票时机含冷冻期、714.买卖股票的最佳时机含手续费-CSDN博客

本文链接：https://blog.csdn.net/LuckyYH__/article/details/142219358

提示：DDU，供自己复习使用。欢迎大家前来讨论~

文章目录

题目
题目一：188.买卖股票的最佳时机IV
解题思路：

题目二：309.最佳买卖股票时机含冷冻期
解题思路：

题目三： 714.买卖股票的最佳时机含手续费
解题思路

股票总结

题目

题目一：188.买卖股票的最佳时机IV

[188. 买卖股票的最佳时机 IV](https://leetcode.cn/problems/combinations/)

解题思路：

买卖股票的进阶版，这里要求至多有k次交易。

动规五部曲，分析如下：

确定dp数组以及下标的含义

在动态规划：123.买卖股票的最佳时机III (opens new window)中，定义了一个二维dp数组，本题其实依然可以用一个二维dp数组。

使用二维数组 dp[i][j] ：第i天的状态为j，所剩下的最大现金是dp[i][j]

j的状态表示为：

0 表示不操作
1 第一次买入
2 第一次卖出
3 第二次买入
4 第二次卖出
…

规律: 除了0以外，偶数就是卖出，奇数就是买入。

题目要求是至多有K笔交易，那么j的范围就定义为 2 * k + 1 就可以了。

所以二维dp数组的C++定义为：

vector<vector<int>> dp(prices.size(), vector<int>(2 * k + 1, 0));

确定递推公式

还要强调一下：dp[i][1]，表示的是第i天，买入股票的状态，并不是说一定要第i天买入股票，这是很多同学容易陷入的误区。

达到dp[i][1]状态，有两个具体操作：

操作一：第i天买入股票了，那么dp[i][1] = dp[i - 1][0] - prices[i]
操作二：第i天没有操作，而是沿用前一天买入的状态，即：dp[i][1] = dp[i - 1][1]

选最大的，所以 dp[i][1] = max(dp[i - 1][0] - prices[i], dp[i - 1][1]);

同理dp[i][2]也有两个操作：

操作一：第i天卖出股票了，那么dp[i][2] = dp[i - 1][1] + prices[i]
操作二：第i天没有操作，沿用前一天卖出股票的状态，即：dp[i][2] = dp[i - 1][2]

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

同理可以类比剩下的状态，代码如下：

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]);
}

本题和动态规划：123.买卖股票的最佳时机III (opens new window)最大的区别就是这里要类比j为奇数是买，偶数是卖的状态。

dp数组如何初始化
1. dp[0][0] = 0：第0天没有进行任何操作，收益为0。
2. dp[0][1] = -prices[0]：第0天进行了第一次买入操作，需要支付购买股票的费用，因此收益为负。
3. dp[0][2] = 0：第0天进行了第一次卖出操作，当天买入当天卖出，收益为0。
4. dp[0][3] = -prices[0]：第0天进行了第二次买入操作，需要再次支付购买股票的费用，因此收益为负。
5. dp[0][4] = 0：第0天进行了第二次卖出操作，由于之前已经卖出过一次，所以这次卖出不会改变收益，收益为0。

对于 dp[0][j] 当 j 为奇数时，都初始化为 -prices[0]，这是因为奇数次交易意味着至少有一次买入操作，而第0天的买入操作会导致收益减少 prices[0]

代码如下：

for (int j = 1; j < 2 * k; j += 2) {
    dp[0][j] = -prices[0];
}

在初始化的地方同样要类比j为偶数是卖、奇数是买的状态。

确定遍历顺序

从递归公式其实已经可以看出，一定是从前向后遍历，因为dp[i]，依靠dp[i - 1]的数值。

举例推导dp数组

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

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

最后一次卖出，一定是利润最大的，dp[prices.size() - 1][2 * k]即红色部分就是最后求解。

以上分析完毕，C++代码如下：

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];
    }
};

时间复杂度: O(n * k)，其中 n 为 prices 的长度
空间复杂度: O(n * k)

题目二：309.最佳买卖股票时机含冷冻期

309. 买卖股票的最佳时机含冷冻期

解题思路：

本题加上了一个冷冻期

有两个状态，持有股票后的最多现金，和不持有股票的最多现金。

动规五部曲，分析如下：

确定dp数组以及下标的含义

dp[i][j]，第i天状态为j，所剩的最多现金为dp[i][j]。

具体可以区分出如下四个状态：

状态一：持有股票状态（今天买入股票，或者是之前就买入了股票然后没有操作，一直持有）
不持有股票状态，这里就有两种卖出股票状态
- 状态二：保持卖出股票的状态（两天前就卖出了股票，度过一天冷冻期。或者是前一天就是卖出股票状态，一直没操作）
- 状态三：今天卖出股票
状态四：今天为冷冻期状态，但冷冻期状态不可持续，只有一天！

j的状态为：

0：状态一
1：状态二
2：状态三
3：状态四

状态表示的不是某一天的操作，而是到那一天为止的交易状态。这里的状态指的是持有股票的状态，而不是指某一天具体买入股票的操作。

确定递推公式

达到买入股票状态（状态一）即：dp[i][0]，有两个具体操作：

操作一：前一天就是持有股票状态（状态一），dp[i][0] = dp[i - 1][0]
操作二：今天买入了，有两种情况
- 前一天是冷冻期（状态四），dp[i - 1][3] - prices[i]
- 前一天是保持卖出股票的状态（状态二），dp[i - 1][1] - prices[i]

那么dp[i][0] = max(dp[i - 1][0], dp[i - 1][3] - prices[i], dp[i - 1][1] - prices[i]);

达到保持卖出股票状态（状态二）即：dp[i][1]，有两个具体操作：

操作一：前一天就是状态二
操作二：前一天是冷冻期（状态四）

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

达到今天就卖出股票状态（状态三），即：dp[i][2] ，只有一个操作：

昨天一定是持有股票状态（状态一），今天卖出

即：dp[i][2] = dp[i - 1][0] + prices[i];

达到冷冻期状态（状态四），即：dp[i][3]，只有一个操作：

昨天卖出了股票（状态三）

dp[i][3] = dp[i - 1][2];

综上分析，递推代码如下：

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

dp数组如何初始化

第0天的初始化情况：

持有股票状态（状态一）：dp[0][1] = -prices[0]。这个状态表示在第0天买入了股票，因此持有股票的成本是负的，即 -prices[0]。这里的负号表示你支付了这笔钱。

保持卖出股票状态（状态二）：dp[0][2] = 0。这个状态表示在第0天之前已经卖出了股票，因此不持有股票，收益为0。这个状态是后续可能再次买入股票的前提。

今天卖出了股票（状态三）：dp[0][3] = 0。这个状态表示在第0天卖出了股票，由于是当天卖出，所以收益为0，表示没有额外的收益或损失。

确定遍历顺序

从递归公式上可以看出，dp[i] 依赖于 dp[i-1]，所以是从前向后遍历。

举例推导dp数组

以 [1,2,3,0,2] 为例，dp数组如下：

309.最佳买卖股票时机含冷冻期

在计算最多两次交易的最大收益时，最后结果应考虑三种状态：持有股票状态（状态二）、今天卖出股票状态（状态三）和冷冻期状态（状态四），并取这三种状态的最大值作为最终答案。

代码如下：

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

时间复杂度：O(n)
空间复杂度：O(n)

题目三： 714.买卖股票的最佳时机含手续费

714. 买卖股票的最佳时机含手续费

解题思路

贪心算法：
- 适用于“买卖股票的最佳时机含手续费”问题。
- 时间复杂度：O(n)，其中n是交易天数。
- 空间复杂度：O(1)，不需要额外存储空间。
- 算法理解起来可能有些困难，容易出错。
动态规划算法：
- 与“买卖股票的最佳时机II”问题类似，但需要在卖出股票时减去手续费。
- 动态规划通过维护一个二维数组 dp[i][j] 来解决问题，其中 dp[i][0] 表示第i天持有股票的最大现金，dp[i][1] 表示第i天不持有股票的最大现金。
- 状态转移方程：
  - dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] - prices[i])：第i天持有股票的状态可以由前一天持有股票或前一天不持有股票并买入股票得到。
  - dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] + prices[i] - fee)：第i天不持有股票的状态可以由前一天不持有股票或前一天持有股票并卖出股票（减去手续费）得到。
- 与“买卖股票的最佳时机II”的主要区别在于卖出股票时需要减去手续费。

以上分析完毕，C++代码如下：

class Solution {
public:
    int maxProfit(vector<int>& prices, int fee) {
        int n = prices.size();
        vector<vector<int>> dp(n, vector<int>(2, 0));
        dp[0][0] -= prices[0]; // 持股票
        for (int i = 1; i < n; i++) {
            dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] - prices[i]);
            dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] + prices[i] - fee);
        }
        return max(dp[n - 1][0], dp[n - 1][1]);
    }
};