买卖股票问题-代码随想录-刷题笔记
121. 买卖股票的最佳时机：买卖一次
暴力超时
//时间复杂度：O(n^2)
//空间复杂度：O(1)
class Solution {
public:
int maxProfit(vector<int>& prices) {
int result = 0;
for (int i = 0; i < prices.size(); i++) {
for (int j = i + 1; j < prices.size(); j++){
result = max(result, prices[j] - prices[i]);
}
}
return result;
}
};
贪心
因为股票就买卖一次，那么贪心的想法很自然就是取最左最小值，取最右最大值，那么得到的差值就是最大利润。
//时间复杂度：O(n)
//空间复杂度：O(1)
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数组（dp table）以及下标的含义
dp[i][0]:表示第i天持有股票所得最多现金
dp[i][1] 表示第i天不持有股票所得最多现金
“持有”不代表就是当天“买入”！也有可能是昨天就买入了，今天保持持有的状态
2.确定递推公式
dp[i][0]可以由2个状态推出来
- 第i-1天就持有股票，保持现状，即dp[i-1][0]
- 第i天买入股票,-prices[i]
- 即dp[i][0] = max(dp[i - 1][0], -prices[i]);
dp[i][1]可以由2个状态推出来
- 第i-1天就不持有股票，即dp[i-1][1]
- 第i天卖出股票,dp[i-1][0]+prices[i]
- 即dp[i][1] = max(dp[i - 1][1], dp[i-1][0]+prices[i]);
3.初始化
那么dp[0][0]表示第0天持有股票，此时的持有股票就一定是买入股票了，因为不可能有前一天推出来，所以dp[0][0] -= prices[0];
dp[0][1]表示第0天不持有股票，不持有股票那么现金就是0，所以dp[0][1] = 0;
4.确定遍历顺序
从递推公式可以看出dp[i]都是由dp[i - 1]推导出来的，那么一定是从前向后遍历。
5.举例推导dp数组
整体代码
// 版本一
//时间复杂度：O(n)
//空间复杂度：O(n)
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(1)
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];
}
};
122.买卖股票的最佳时机II：买卖多次
贪心
class Solution {
public:
int maxProfit(vector<int>& prices) {
//只要今天买，明天卖赚钱就行
int sum=0;
for(int i=1;i<prices.size();i++){
if(prices[i]>prices[i-1]){
sum+=prices[i]-prices[i-1];
}
}
return sum;
}
};
动态规划
1）dp数组的含义
dp[i][0]:表示第i天持有股票所得最多现金
dp[i][1] 表示第i天不持有股票所得最多现金
“持有”不代表就是当天“买入”！也有可能是昨天就买入了，今天保持持有的状态
2）递推公式
因为一只股票可以买卖多次，所以当第i天买入股票的时候，所持有的现金可能有之前买卖过的利润。
那么第i天持有股票即dp[i][0]，如果是第i天买入股票，所得现金就是昨天不持有股票的所得现金减去今天的股票价格 即：dp[i - 1][1] - prices[i]。
整体代码
//时间复杂度：O(n)
//空间复杂度：O(n)
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(1)
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], dp[(i - 1) % 2][1] - 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];
}
};
123.买卖股票的最佳时机III-最多买卖2次
至多买卖两次，这意味着可以买卖一次，可以买卖两次，也可以不买卖。
1）dp数组的含义
一天一共就有五个状态
0.没有操作 （其实我们也可以不设置这个状态）
- 第一次持有股票
- 第一次不持有股票
- 第二次持有股票
- 第二次不持有股票
dp[i][j]中 i表示第i天，j为 [0 - 4] 五个状态，dp[i][j]表示第i天状态j所剩最大现金。
需要注意：dp[i][1]，表示的是第i天，买入股票的状态，并不是说一定要第i天买入股票，这是很多同学容易陷入的误区。
例如 dp[i][1] ，并不是说 第i天一定买入股票，有可能 第 i-1天 就买入了，那么 dp[i][1] 延续买入股票的这个状态。
2）递推公式
达到dp[i][1]状态，有2个具体操作
一：第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]状态，有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]状态，有2个具体操作
一：第i天第二次买入股票了，dp[i][3]=dp[i-1][2]-prices[i]
二：第i天没有操作，沿用前一天卖出股票的状态，dp[i][3]=dp[i-1][3]
选最大的dp[i][3]=max(dp[i-1][2]-prices[i],dp[i-1][3])
达到dp[i][4]状态，有2个具体操作
一：第i天第二次卖出股票了，dp[i][4]=dp[i-1][3]+prices[i]
二：第i天没有操作，沿用前一天卖出股票的状态，dp[i][4]=dp[i-1][4]
选最大的dp[i][4]=max(dp[i-1][3]+prices[i],dp[i-1][4])
3.dp数组如何初始化
dp[0][0] = 0;
dp[0][1] = -prices[0];
dp[0][2] = 0;dp[0][3] = -prices[0];
dp[0][4] = 0;
4.确定遍历顺序
一定是从前向后遍历，因为dp[i]，依靠dp[i - 1]的数值。
5.举例推导dp数组
整体代码
// 版本一
//时间复杂度：O(n)
//空间复杂度：O(n × 5)
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(1)
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];
}
};
扩展
可以不设置“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];
}
};
188.买卖股票的最佳时机IV-买卖k次
1）dp数组的含义
一天一共就有2k+1个状态
0.没有操作 （其实我们也可以不设置这个状态）
- 第一次持有股票
- 第一次不持有股票
- 第二次持有股票
- 第二次不持有股票
- 第三次持有股票
- 第三次不持有股票
…
dp[i][j]中 i表示第i天，j为 [0-2k] 2k+1个状态，dp[i][j]表示第i天状态j所剩最大现金。
2）递推公式:发现规律，奇数买，偶数卖
dp[i][1]=max(dp[i-1][0]-prices[i],dp[i-1][1])
dp[i][2]=max(dp[i-1][1]+prices[i],dp[i-1][2])
dp[i][3]=max(dp[i-1][2]-prices[i],dp[i-1][3])
...
for(int j=0;j<2*k-1;j+=2){
dp[i][j+1]=max(dp[i-1][j]-prices[i],dp[i-1][j+1]);
dp[i][j+2]=max(dp[i-1][j+1]+prices[i],dp[i-1][j+2]);
}
3.dp数组如何初始化
for(int j=1;j<2k;j+=2{
dp[0][j]= -prices[0];
}
4.确定遍历顺序
一定是从前向后遍历，因为dp[i]，依靠dp[i - 1]的数值
5.举例推导dp数组
整体代码
//时间复杂度: O(n * k)，其中 n 为 prices 的长度
//空间复杂度: O(n * 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];
}
};
309.最佳买卖股票时机含冷冻期：买卖多次
1）dp数组的含义
一天一共有4个状态
状态1：持有股票:今天买入股票，或者之昨天就有了保持
不持有股票：
状态2：保持卖出股票的状态:两天前就卖出了股票，度过一天冷冻期，或者昨天卖出保持
状态3：今天卖出股票
状态4：今天是冷冻期，只有一天
j的状态为：
- 0：状态一
- 1：状态二
- 2：状态三
- 3：状态四
dp[i][j]中 i表示第i天，j为 0-3个状态，dp[i][j]表示第i天状态j所剩最大现金
2）递推公式
**状态1：dp[i][0]**持有股票
操作一：昨天持有股票保持dp[i][0]=dp[i-1][0]
操作二：今天买入了
1.昨天是冷冻期，今天买入dp[i][0]=dp[i-1][3]-prices[i]
2.昨天保持不持有股票的状态，今天买入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]}
**状态2：dp[i][1]**不持有股票
**操作一：**两天前就卖出了股票，度过一天冷冻期dp[i][1]=dp[i-1][3]
**操作二：**昨天卖出然后保持,dp[i][1]=dp[i-1][1]
dp[i][1]=max(dp[i-1][3],dp[i-1][1])
**状态3：dp[i][2]**不持有股票
昨天持有，今天卖出
dp[i][2]=dp[i-1][0]+prices[i]
状态4：今天是冷冻期
昨天卖出了股票，今天才冷冻
dp[i][3]=dp[i-1][2]
3.dp数组如何初始化
dp[0][0]=-prices[0];
dp[0][1]=0
dp[0][2]=0
dp[0][3]=0
4.方向
从前到后
5.举例
整体代码
//时间复杂度：O(n)
//空间复杂度：O(n)
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]));
}
};
714.买卖股票的最佳时机含手续费：买卖多次
1）dp[i][j]表示第i天状态j所剩最大现金
状态0持有，状态1不持有
2）递推公式
dp[i][0]=max(dp[i-1][0],dp[i-1][1]-prices[0])
dp[i][1]=max(dp[i-1][1],dp[i-1][0]+prices[0]-fee)
3)初始化
dp[0][0]=-prices[0]
4)方向
从前到后
整体代码
//时间复杂度：O(n)
//空间复杂度：O(n)
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(1)
class Solution {
public:
int maxProfit(vector<int>& prices, int fee) {
int result = 0;
int minPrice = prices[0]; // 记录最低价格
for (int i = 1; i < prices.size(); i++) {
// 情况二：相当于买入
if (prices[i] < minPrice) minPrice = prices[i];
// 情况三：保持原有状态（因为此时买则不便宜，卖则亏本）
if (prices[i] >= minPrice && prices[i] <= minPrice + fee) {
continue;
}
// 计算利润，可能有多次计算利润，最后一次计算利润才是真正意义的卖出
if (prices[i] > minPrice + fee) {
result += prices[i] - minPrice - fee;
minPrice = prices[i] - fee; // 情况一，这一步很关键，避免重复扣手续费
}
}
return result;
}
};