mirror of
https://github.com/youngyangyang04/leetcode-master.git
synced 2026-02-02 18:39:09 +08:00
486 lines
18 KiB
Markdown
486 lines
18 KiB
Markdown
<p align="center">
|
||
<a href="https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ" target="_blank">
|
||
<img src="https://code-thinking-1253855093.file.myqcloud.com/pics/20210924105952.png" width="1000"/>
|
||
</a>
|
||
<p align="center"><strong><a href="https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A">参与本项目</a>，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！</strong></p>
|
||
|
||
之前我们已经把力扣上股票系列的题目都讲过的，但没有来一篇股票总结，来帮大家高屋建瓴，所以总结篇这就来了！
|
||
|
||
|
||
|
||
* [动态规划：121.买卖股票的最佳时机](https://programmercarl.com/0121.买卖股票的最佳时机.html)
|
||
* [动态规划：122.买卖股票的最佳时机II](https://programmercarl.com/0122.买卖股票的最佳时机II（动态规划）.html)
|
||
* [动态规划：123.买卖股票的最佳时机III](https://programmercarl.com/0123.买卖股票的最佳时机III.html)
|
||
* [动态规划：188.买卖股票的最佳时机IV](https://programmercarl.com/0188.买卖股票的最佳时机IV.html)
|
||
* [动态规划：309.最佳买卖股票时机含冷冻期](https://programmercarl.com/0309.最佳买卖股票时机含冷冻期.html)
|
||
* [动态规划：714.买卖股票的最佳时机含手续费](https://programmercarl.com/0714.买卖股票的最佳时机含手续费（动态规划）.html)
|
||
|
||
## 卖股票的最佳时机
|
||
|
||
[动态规划：121.买卖股票的最佳时机](https://programmercarl.com/0121.买卖股票的最佳时机.html)，**股票只能买卖一次，问最大利润**。
|
||
|
||
【贪心解法】
|
||
|
||
取最左最小值，取最右最大值，那么得到的差值就是最大利润，代码如下：
|
||
```CPP
|
||
class Solution {
|
||
public:
|
||
int maxProfit(vector<int>& prices) {
|
||
int low = INT_MAX;
|
||
int result = 0;
|
||
for (int i = 0; i < prices.size(); i++) {
|
||
low = min(low, prices[i]); // 取最左最小价格
|
||
result = max(result, prices[i] - low); // 直接取最大区间利润
|
||
}
|
||
return result;
|
||
}
|
||
};
|
||
```
|
||
|
||
【动态规划】
|
||
|
||
* dp[i][0] 表示第i天持有股票所得现金。
|
||
* dp[i][1] 表示第i天不持有股票所得现金。
|
||
|
||
如果第i天持有股票即dp[i][0]， 那么可以由两个状态推出来
|
||
* 第i-1天就持有股票，那么就保持现状，所得现金就是昨天持有股票的所得现金 即：dp[i - 1][0]
|
||
* 第i天买入股票，所得现金就是买入今天的股票后所得现金即：-prices[i]
|
||
所以dp[i][0] = max(dp[i - 1][0], -prices[i]);
|
||
|
||
如果第i天不持有股票即dp[i][1]， 也可以由两个状态推出来
|
||
* 第i-1天就不持有股票，那么就保持现状，所得现金就是昨天不持有股票的所得现金 即：dp[i - 1][1]
|
||
* 第i天卖出股票，所得现金就是按照今天股票佳价格卖出后所得现金即：prices[i] + dp[i - 1][0]
|
||
所以dp[i][1] = max(dp[i - 1][1], prices[i] + dp[i - 1][0]);
|
||
|
||
代码如下：
|
||
|
||
```CPP
|
||
// 版本一
|
||
class Solution {
|
||
public:
|
||
int maxProfit(vector<int>& prices) {
|
||
int len = prices.size();
|
||
if (len == 0) return 0;
|
||
vector<vector<int>> dp(len, vector<int>(2));
|
||
dp[0][0] -= prices[0];
|
||
dp[0][1] = 0;
|
||
for (int i = 1; i < len; i++) {
|
||
dp[i][0] = max(dp[i - 1][0], -prices[i]);
|
||
dp[i][1] = max(dp[i - 1][1], prices[i] + dp[i - 1][0]);
|
||
}
|
||
return dp[len - 1][1];
|
||
}
|
||
};
|
||
```
|
||
* 时间复杂度：$O(n)$
|
||
* 空间复杂度：$O(n)$
|
||
|
||
使用滚动数组，代码如下：
|
||
|
||
```CPP
|
||
// 版本二
|
||
class Solution {
|
||
public:
|
||
int maxProfit(vector<int>& prices) {
|
||
int len = prices.size();
|
||
vector<vector<int>> dp(2, vector<int>(2)); // 注意这里只开辟了一个2 * 2大小的二维数组
|
||
dp[0][0] -= prices[0];
|
||
dp[0][1] = 0;
|
||
for (int i = 1; i < len; i++) {
|
||
dp[i % 2][0] = max(dp[(i - 1) % 2][0], -prices[i]);
|
||
dp[i % 2][1] = max(dp[(i - 1) % 2][1], prices[i] + dp[(i - 1) % 2][0]);
|
||
}
|
||
return dp[(len - 1) % 2][1];
|
||
}
|
||
};
|
||
```
|
||
|
||
* 时间复杂度：$O(n)$
|
||
* 空间复杂度：$O(1)$
|
||
|
||
|
||
## 买卖股票的最佳时机II
|
||
|
||
[动态规划：122.买卖股票的最佳时机II](https://programmercarl.com/0122.买卖股票的最佳时机II（动态规划）.html)可以多次买卖股票，问最大收益。
|
||
|
||
|
||
【贪心解法】
|
||
|
||
收集每天的正利润便可，代码如下：
|
||
|
||
```CPP
|
||
class Solution {
|
||
public:
|
||
int maxProfit(vector<int>& prices) {
|
||
int result = 0;
|
||
for (int i = 1; i < prices.size(); i++) {
|
||
result += max(prices[i] - prices[i - 1], 0);
|
||
}
|
||
return result;
|
||
}
|
||
};
|
||
```
|
||
|
||
* 时间复杂度：$O(n)$
|
||
* 空间复杂度：$O(1)$
|
||
|
||
|
||
【动态规划】
|
||
|
||
dp数组定义：
|
||
|
||
* dp[i][0] 表示第i天持有股票所得现金
|
||
* dp[i][1] 表示第i天不持有股票所得最多现金
|
||
|
||
|
||
如果第i天持有股票即dp[i][0]， 那么可以由两个状态推出来
|
||
* 第i-1天就持有股票，那么就保持现状，所得现金就是昨天持有股票的所得现金 即：dp[i - 1][0]
|
||
* 第i天买入股票，所得现金就是昨天不持有股票的所得现金减去 今天的股票价格 即：dp[i - 1][1] - prices[i]
|
||
|
||
**注意这里和[121. 买卖股票的最佳时机](https://programmercarl.com/0121.买卖股票的最佳时机.html)唯一不同的地方，就是推导dp[i][0]的时候，第i天买入股票的情况**。
|
||
|
||
在[121. 买卖股票的最佳时机](https://programmercarl.com/0121.买卖股票的最佳时机.html)中，因为股票全程只能买卖一次，所以如果买入股票，那么第i天持有股票即dp[i][0]一定就是 -prices[i]。
|
||
|
||
而本题，因为一只股票可以买卖多次，所以当第i天买入股票的时候，所持有的现金可能有之前买卖过的利润。
|
||
|
||
代码如下：（注意代码中的注释，标记了和121.买卖股票的最佳时机唯一不同的地方）
|
||
|
||
```CPP
|
||
class Solution {
|
||
public:
|
||
int maxProfit(vector<int>& prices) {
|
||
int len = prices.size();
|
||
vector<vector<int>> dp(len, vector<int>(2, 0));
|
||
dp[0][0] -= prices[0];
|
||
dp[0][1] = 0;
|
||
for (int i = 1; i < len; i++) {
|
||
dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] - prices[i]); // 注意这里是和121. 买卖股票的最佳时机唯一不同的地方。
|
||
dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] + prices[i]);
|
||
}
|
||
return dp[len - 1][1];
|
||
}
|
||
};
|
||
```
|
||
|
||
* 时间复杂度：$O(n)$
|
||
* 空间复杂度：$O(n)$
|
||
|
||
|
||
## 买卖股票的最佳时机III
|
||
|
||
[动态规划：123.买卖股票的最佳时机III](https://programmercarl.com/0123.买卖股票的最佳时机III.html)最多买卖两次，问最大收益。
|
||
|
||
【动态规划】
|
||
|
||
一天一共就有五个状态，
|
||
0. 没有操作
|
||
1. 第一次买入
|
||
2. 第一次卖出
|
||
3. 第二次买入
|
||
4. 第二次卖出
|
||
|
||
dp[i][j]中 i表示第i天，j为 [0 - 4] 五个状态，dp[i][j]表示第i天状态j所剩最大现金。
|
||
|
||
|
||
达到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])
|
||
|
||
同理可推出剩下状态部分：
|
||
|
||
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]);
|
||
|
||
代码如下：
|
||
|
||
```CPP
|
||
// 版本一
|
||
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)$
|
||
|
||
当然，大家可以看到力扣官方题解里的一种优化空间写法，我这里给出对应的C++版本：
|
||
|
||
```CPP
|
||
// 版本二
|
||
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)$
|
||
|
||
**这种写法看上去简单，其实思路很绕，不建议大家这么写，这么思考，很容易把自己绕进去！** 对于本题，把版本一的写法研究明白，足以！
|
||
|
||
## 买卖股票的最佳时机IV
|
||
|
||
[动态规划：188.买卖股票的最佳时机IV](https://programmercarl.com/0188.买卖股票的最佳时机IV.html) 最多买卖k笔交易，问最大收益。
|
||
|
||
使用二维数组 dp[i][j] ：第i天的状态为j，所剩下的最大现金是dp[i][j]
|
||
|
||
j的状态表示为：
|
||
|
||
* 0 表示不操作
|
||
* 1 第一次买入
|
||
* 2 第一次卖出
|
||
* 3 第二次买入
|
||
* 4 第二次卖出
|
||
* .....
|
||
|
||
**除了0以外，偶数就是卖出，奇数就是买入**。
|
||
|
||
|
||
2. 确定递推公式
|
||
|
||
达到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][0]);
|
||
|
||
同理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][i] + prices[i], dp[i][2])
|
||
|
||
同理可以类比剩下的状态，代码如下：
|
||
|
||
```CPP
|
||
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]);
|
||
}
|
||
```
|
||
|
||
整体代码如下：
|
||
|
||
```CPP
|
||
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];
|
||
}
|
||
};
|
||
```
|
||
|
||
当然有的解法是定义一个三维数组dp[i][j][k]，第i天，第j次买卖，k表示买还是卖的状态，从定义上来讲是比较直观。但感觉三维数组操作起来有些麻烦，直接用二维数组来模拟三位数组的情况，代码看起来也清爽一些。
|
||
|
||
## 最佳买卖股票时机含冷冻期
|
||
|
||
[动态规划：309.最佳买卖股票时机含冷冻期](https://programmercarl.com/0309.最佳买卖股票时机含冷冻期.html)可以多次买卖但每次卖出有冷冻期1天。
|
||
|
||
相对于[动态规划：122.买卖股票的最佳时机II](https://programmercarl.com/0122.买卖股票的最佳时机II（动态规划）.html)，本题加上了一个冷冻期。
|
||
|
||
|
||
在[动态规划：122.买卖股票的最佳时机II](https://programmercarl.com/0122.买卖股票的最佳时机II（动态规划）.html) 中有两个状态，持有股票后的最多现金，和不持有股票的最多现金。本题则可以花费为四个状态
|
||
|
||
dp[i][j]：第i天状态为j，所剩的最多现金为dp[i][j]。
|
||
|
||
具体可以区分出如下四个状态：
|
||
|
||
* 状态一：买入股票状态（今天买入股票，或者是之前就买入了股票然后没有操作）
|
||
* 卖出股票状态，这里就有两种卖出股票状态
|
||
* 状态二：两天前就卖出了股票，度过了冷冻期，一直没操作，今天保持卖出股票状态
|
||
* 状态三：今天卖出了股票
|
||
* 状态四：今天为冷冻期状态，但冷冻期状态不可持续，只有一天！
|
||
|
||
|
||
达到买入股票状态（状态一）即：dp[i][0]，有两个具体操作：
|
||
|
||
* 操作一：前一天就是持有股票状态（状态一），dp[i][0] = dp[i - 1][0]
|
||
* 操作二：今天买入了，有两种情况
|
||
* 前一天是冷冻期（状态四），dp[i - 1][3] - prices[i]
|
||
* 前一天是保持卖出股票状态（状态二），dp[i - 1][1] - prices[i]
|
||
|
||
所以操作二取最大值，即：max(dp[i - 1][3], dp[i - 1][1]) - prices[i]
|
||
|
||
那么dp[i][0] = max(dp[i - 1][0], max(dp[i - 1][3], 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]，只有一个操作：
|
||
|
||
* 操作一：昨天卖出了股票（状态三）
|
||
|
||
p[i][3] = dp[i - 1][2];
|
||
|
||
综上分析，递推代码如下：
|
||
|
||
```CPP
|
||
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];
|
||
```
|
||
|
||
整体代码如下：
|
||
|
||
```CPP
|
||
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], 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.买卖股票的最佳时机含手续费](https://programmercarl.com/0714.买卖股票的最佳时机含手续费（动态规划）.html) 可以多次买卖，但每次有手续费。
|
||
|
||
|
||
相对于[动态规划：122.买卖股票的最佳时机II](https://programmercarl.com/0122.买卖股票的最佳时机II（动态规划）.html)，本题只需要在计算卖出操作的时候减去手续费就可以了，代码几乎是一样的。
|
||
|
||
唯一差别在于递推公式部分，所以本篇也就不按照动规五部曲详细讲解了，主要讲解一下递推公式部分。
|
||
|
||
这里重申一下dp数组的含义：
|
||
|
||
dp[i][0] 表示第i天持有股票所省最多现金。
|
||
dp[i][1] 表示第i天不持有股票所得最多现金
|
||
|
||
|
||
如果第i天持有股票即dp[i][0]， 那么可以由两个状态推出来
|
||
* 第i-1天就持有股票，那么就保持现状，所得现金就是昨天持有股票的所得现金 即：dp[i - 1][0]
|
||
* 第i天买入股票，所得现金就是昨天不持有股票的所得现金减去 今天的股票价格 即：dp[i - 1][1] - prices[i]
|
||
|
||
|
||
所以：dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] - prices[i]);
|
||
|
||
|
||
在来看看如果第i天不持有股票即dp[i][1]的情况， 依然可以由两个状态推出来
|
||
* 第i-1天就不持有股票，那么就保持现状，所得现金就是昨天不持有股票的所得现金 即：dp[i - 1][1]
|
||
* 第i天卖出股票，所得现金就是按照今天股票价格卖出后所得现金，**注意这里需要有手续费了**即：dp[i - 1][0] + prices[i] - fee
|
||
|
||
所以：dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] + prices[i] - fee);
|
||
|
||
**本题和[动态规划：122.买卖股票的最佳时机II](https://programmercarl.com/0122.买卖股票的最佳时机II（动态规划）.html)的区别就是这里需要多一个减去手续费的操作**。
|
||
|
||
以上分析完毕，代码如下：
|
||
|
||
```CPP
|
||
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]);
|
||
}
|
||
};
|
||
```
|
||
|
||
* 时间复杂度：$O(n)$
|
||
* 空间复杂度：$O(n)$
|
||
|
||
|
||
## 总结
|
||
|
||
至此，股票系列正式剧终，全部讲解完毕！
|
||
|
||
从买买一次到买卖多次，从最多买卖两次到最多买卖k次，从冷冻期再到手续费，最后再来一个股票大总结，可以说对股票系列完美收官了。
|
||
|
||
「代码随想录」值得推荐给身边每一位学习算法的朋友同学们，关注后都会发现相见恨晚！
|
||
|
||
|
||
## 其他语言版本
|
||
|
||
|
||
Java：
|
||
|
||
|
||
Python：
|
||
|
||
|
||
Go：
|
||
|
||
|
||
|
||
|
||
-----------------------
|
||
<div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>
|