leetcode买卖股票最佳时机相关问题分析

已于 2023-04-12 09:57:05 修改
阅读量523 收藏
点赞数
文章标签： 算法 动态规划 数据结构
于 2023-04-10 21:33:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45248909/article/details/130067881
版权

买卖股票最佳时机相关问题分析

前言

本文介绍买卖股票最佳时机的相关问题。在阅读代码随想录时对这部分的递推关系式怎么得来的有些疑问，本文在此基础上加上自己的理解，若有错误望指正。

1、121买卖股票的最佳时机

题目：
给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。
你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。
返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。
示例 1：
输入：[7,1,5,3,6,4]
输出：5
解释：在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格；同时，你不能在买入前卖出股票。
示例 2：
输入：prices = [7,6,4,3,1]
输出：0
解释：在这种情况下, 没有交易完成, 所以最大利润为 0。

思路分析

股票有买与卖两种状态，买之后没有卖之前用户都可以看作亏本，此时的利润为负数，股票卖了之后才有利润（牢记这点）。下面我们分析题目要求的利润到底是什么。

根据题目可以知道，题目要求的最大利润就是在第i天已经把股票卖出去后的最大利润（一定是已经卖出去了，但不一定是第i天卖出去的，这个卖出去可以看作手上没有股票）。我们把这个利润记作 dp1[i] 。

 dp1[i]:第i天的最大利润（此时用户手上没有股票）。

既然已经知道dp1[i]的含义，那么我们很容易的知道dp1[i]的递推关系式：

 dp1[i]=max(dp1[i-1],price[i]+dp2[i-1])
 注意此时出现了一个新的dp数组dp2，具体含义接下来我会进行分析。

dp1[i] 为什么要写成这种形式呢，因为根据dp1[i]的定义可以知道他可以通过两部分求解如下表：

含义
不是第i天卖，那么利润为dp1[i-1] 。
是第i天卖的，那么利润为第i天的价格加上i-1天内有股票但是没有卖出去的最大利润（这个利润为负数）

将dp2[i]定义为i天内有股票但是没有卖出去的最大利润（买了但是没有卖出去），因此是第i天卖出去的利润就是dp2[i-1]+price[i] 。(注意dp2这个dp数组都是负数)。所以我们还要建立dp2[i]的递推关系式，根据其定义可知它也可以通过两部分进行求解：

 dp2[i]:i天内买了股票但是没有卖出去的最大利润（此时用户手上有股票）。
含义
不是第i天买的，那么利润为dp2[i-1] 。
是第i天买的，那么利润为-price[i]（即用price[i]的价格买了但是没有卖出去，相当于白花了price[i]）。

根据上述分析我们就可以得到dp1的递推关系式：

 dp1[i]=max(dp1[i-1],price[i]+dp2[i-1])
 dp2[i]=max(dp2[i-1],-price[i])
 我们可以只用一个二维数组来替代两个一维数组就形成了代码随想录中的形式：
dp[i][1] = max(dp[i - 1][1], prices[i] + dp[i - 1][0]);
dp[i][0] = max(dp[i - 1][0], -prices[i]);

知道递推关系式后，那么如何进行初始化呢，dp[0][1]表示第0天的利润（此时用户没有股票），那么自然将其初始化为0，而dp[0][0] 表示0天内买了股票但是没有卖出去的最大利润（此时用户手上有股票），则将其初始化为-price[0]即可。

代码及运行结果

代码如下：

#include<iostream>
#include<vector>
using namespace std;

class solution
{
public:
	int getres(vector<int>& prices)
	{
		vector<vector<int>> dp(prices.size(), vector<int>(2,0));
		dp[0][0] = -prices[0];
		dp[0][1] = 0;
		for (int i = 1;i < prices.size();i++)
		{
			dp[i][0] = max(-prices[i], dp[i - 1][0]);
			dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] + prices[i]);
			cout << "第"<<i<<"天的两种利润：" << endl;
			cout << dp[i][0] << "  " << dp[i][1] << endl;
			cout << endl;
		}
		cout << "结果为：" << endl;
		return dp[prices.size() - 1][1];
	}
};

int main()
{
	solution s;
	vector<int> prices = { 7,1,5,3,6,4 };
	cout << s.getres(prices) << endl;
}

运行结果为：

在这里插入图片描述

2、122买卖股票的最佳时机II

题目：
给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。
设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。
注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
示例 1:
输入: [7,1,5,3,6,4]
输出: 7
解释: 在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4。随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6-3 = 3 。

思路分析

相比于121题，本题多了一个条件，就是用户可以进行多笔交易，那么此时的递推关系式就要发生一些改变，首先还是从用户只能进行一笔交易的递推关系式出发：

dp[i][1] = max(dp[i - 1][1], prices[i] + dp[i - 1][0]);
dp[i][0] = max(dp[i - 1][0], -prices[i]);
其中dp[i][1]表示第i天手上没有股票的最大利润
dp[i][0]表示第i天手上有股票的最大利润。

注意由于上述递推关系式是只进行一次交易下的结果，即全程只买一次卖一次，但是本题变成了可以买卖多次（但是不能参与多笔交易）。因此递推关系式需要进行一定变化：

dp[i][1] = max(dp[i - 1][1], prices[i] + dp[i - 1][0]);
dp[i][0] = max(dp[i - 1][0], dp[i-1][1]-prices[i]);
其中dp[i][1]表示第i天手上没有股票的最大利润
dp[i][0]表示第i天手上有股票的最大利润。

比较两种递推关系式，发现在dp[i][0] 的第二部分有了一定变化，由 -prices[i] 变成了 dp[i-1][1]-prices[i] 。这是因为在只进行一次交易时，用户在买之前的本金为0（注意我是将本金按照利润计算），而当进行多次交易之后，用户的本金发生了变化，因为在本次买入的时候可能在之前已经完成了一笔交易，即已经有了一次买入卖出，相当于有了利润，本金发生了变化，因此在计算第 i 天手上有股票的最大利润时需要加上第i-1天手上没有股票的利润。

代码及运行结果

此时的代码如下：

#include<iostream>
#include<vector>
using namespace std;

class solution
{
public:
	int getres(vector<int>& prices)
	{
		vector<vector<int>> dp(prices.size(), vector<int>(2,0));
		dp[0][0] = -prices[0];
		dp[0][1] = 0;
		for (int i = 1;i < prices.size();i++)
		{
			dp[i][0] = max(dp[i - 1][1] -prices[i], dp[i - 1][0]);
			dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] + prices[i]);
			cout << "第"<<i<<"天的两种利润：" << endl;
			cout << dp[i][0] << "  " << dp[i][1] << endl;
			cout << endl;
		}
		cout << "结果为：" << endl;
		return dp[prices.size() - 1][1];
	}
};

int main()
{
	solution s;
	vector<int> prices = { 7,1,5,3,6,4 };
	cout << s.getres(prices) << endl;
}

运行结果为：

在这里插入图片描述

3、123买卖股票的最佳时机III

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

示例 1: 输入：prices = [3,3,5,0,0,3,1,4] 输出：6 解释：在第 4 天（股票价格 = 0）的时候买入，在第 6 天（股票价格 = 3）的时候卖出，这笔交易所能获得利润 = 3-0 = 3 。随后，在第 7 天（股票价格 = 1）的时候买入，在第 8 天 （股票价格 = 4）的时候卖出，这笔交易所能获得利润 = 4-1 = 3。

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

示例 4： 输入：prices = [1] 输出：0

思路分析

本题相比于前面两题的约束条件由发生了改变，但是在本质上还是不变的，我们只需要知道用户的利润一定是通过下面两种递推关系式进行变形得到的，区别在于第i天之前有没有完成过交易，由于题目条件是最多两次交易，因此可能存在第i天之前有过交易，也可能存在没有过交易，所以需要对第i天的状态进行一定分析讨论：

dp[i][1] = max(dp[i - 1][1], prices[i] + dp[i - 1][0]);
dp[i][0] = max(dp[i - 1][0], -prices[i]);
其中dp[i][1]表示第i天手上没有股票的最大利润
dp[i][0]表示第i天手上有股票的最大利润。

dp[i][1] = max(dp[i - 1][1], prices[i] + dp[i - 1][0]);
dp[i][0] = max(dp[i - 1][0], dp[i-1][1]-prices[i]);
其中dp[i][1]表示第i天手上没有股票的最大利润
dp[i][0]表示第i天手上有股票的最大利润。

题目为最多两次交易，因此存在不交易，一次交易，两次交易三种情况，具体进行分解可得到如下状态：

0：用户即没有买股票也没有卖股票
1：第一次持有股票
2：第一次不持有股票
3：第二次持有股票
4：第二次不持有股票

结合这几种状态的含义和递推关系式可以得到每种状态的递推关系式如下：

dp[i][0]=0
dp[i][1]=max(dp[i-1][1],-price[i])
dp[i][2]=max(dp[i-1][2],price[i]+dp[i-1][1])
dp[i][3]=max(dp[i-1][3],dp[i-1][2]-price[i])
dp[i][4]=max(dp[i-1][4],dp[i-1][3]+price[i])
我们以dp[i][4]为例解释为什么递推关系式是这种形式：
dp[i][4]表示第i天手上第二次没有股票的最大利润，那么这种状态下可能是第i天把股票卖出去了，也可能是
第i天没有卖，是i-1天内卖的，到底是哪种情况，取最大值就行了。
如果是第i天把股票卖出去了，那么利润就是卖出去的钱，加上前面几天的利润，这个前面几天的利润是多少，
就和dp[i][3]有关了，因为既然第i天把股票第二次卖出去了，那么第i-1天用户手上一定是第2次有股票，
即为dp[i-1][3].所以此时的最大利润为：dp[i-1][3]+price[i]，同理第i天没有卖出去时，那么肯定是
第i-1天手上第二次没有股票，即为dp[i-1][4]。二者取最大值即为dp[i][4]。

代码及运行结果

经过上述分析可以写出如下代码：

#include<iostream>
#include<vector>
#include <iomanip>
using namespace std;

class solution
{
public:
	int getres(vector<int>& nums)
	{
		vector<vector<int>> dp(nums.size(), vector<int>(5, 0));
		dp[0][1] = -nums[0];
		dp[0][3] = -nums[0];
		for (int i = 1;i < nums.size();i++)
		{
			dp[i][1] = max(dp[i - 1][0] - nums[i], dp[i - 1][1]);
			dp[i][2] = max(dp[i - 1][1] + nums[i], dp[i - 1][2]);
			dp[i][3] = max(dp[i - 1][3], dp[i - 1][2] - nums[i]);
			dp[i][4] = max(dp[i - 1][4], dp[i - 1][3] + nums[i]);
			cout << "第" << i << "天的结果：" << endl;
			for (int j = 0;j < 5;j++)
			{

				cout << std::left << setw(2) << dp[i][j] << "  ";
			}
			cout << endl << endl;;
		}
		cout << "最大利润为：" << endl;
		return dp[nums.size() - 1][4];
	}
};

int main()
{
	solution s;
	vector<int> nums = { 1,2,3,4,5 };
	cout << s.getres(nums) << endl;
	return 0;
}

运行结果为：

在这里插入图片描述

4、188买卖股票的最佳时机IV

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

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

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

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

思路分析

本题相比于123题在思路上没有改变，只是将约束条件从最多两次交易变成了最多k次交易，可以继续按照123题的思路进行分析，此时用户的状态可以分解为如下情况：

0：用户即没有买股票也没有卖股票
1：第一次持有股票
2：第一次不持有股票
3：第二次持有股票
4：第二次不持有股票
......
2k-1:第k次持有股票
2k：第k次不持有股票

由于此时的交易次数为未知数，为了写出每种状态的递推关系式，我们可以先观察一下交易次数最多为两次的递推关系式：

dp[i][1]=max(dp[i-1][1],dp[i][0]-price[i])
dp[i][2]=max(dp[i-1][2],price[i]+dp[i-1][1])
dp[i][3]=max(dp[i-1][3],dp[i-1][2]-price[i])
dp[i][4]=max(dp[i-1][4],dp[i-1][3]+price[i])

很容易就可以发现规律如下：

for(j=1;j<4;j+=2)
dp[i][j]=max(dp[i-1][j],dp[i-1][j-1]-price[i])
dp[i][j+1]=max(dp[i-1][j+1],dp[i-1][j]+price[i])

因此可以写出交易次数最多为k次的递推关系式为：

for(j=1;j<2*k;j+=2)
dp[i][j]=max(dp[i-1][j],dp[i-1][j-1]-price[i])
dp[i][j+1]=max(dp[i-1][j+1],dp[i-1][j]+price[i])

dp数组初始化如下：

for (int j = 1; j < 2 * k; j += 2) 
{
    dp[0][j] = -prices[0];
}
即买入时为-prices[0]，卖出时为0。

代码及运行结果

代码如下：

#include<iostream>
#include<vector>
using namespace std;

class solution
{
public:
	int getres(vector<int>& prices, int& k)
	{
		vector<vector<int>> dp(prices.size(), vector<int>(2 * k + 1, 0));
		for (int j = 1;j < 2 * k+1;j=j+2)
		{
			dp[0][j] = -prices[0];
		}
		for (int i = 1;i < prices.size();i++)
		{
			for (int j = 1;j <= 2 * k;j = j + 2)
			{
				dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - 1] - prices[i]);
				dp[i][j + 1] = max(dp[i - 1][j + 1], dp[i - 1][j] + prices[i]);
			}
		}
		return dp[prices.size() - 1][2 * k];
	}
};

int main()
{
	int k = 2;
	vector<int> prices = {3,2,6,5,0,3};
	solution s;
	cout << s.getres(prices, k);
	return 0;
}

结果就不多赘述。

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

题目：
给定一个整数数组，其中第 i 个元素代表了第 i 天的股票价格 。

设计一个算法计算出最大利润。在满足以下约束条件下，你可以尽可能地完成更多的交易（多次买卖一支股票）:

你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
卖出股票后，你无法在第二天买入股票 (即冷冻期为 1 天)。
示例:

输入: [1,2,3,0,2]
输出: 3
解释: 对应的交易状态为: [买入, 卖出, 冷冻期, 买入, 卖出]

思路分析

本题加入了一个新的约束条件—冷冻期，从而使得用户的状态发生了改变，之前的状态是手上有股票时的最大利润和手上没有股票时的最大利润，现在要考虑冷冻期的影响，需要将状态进一步细分，下面进行具体分析，首先我们观察没有冷冻期时允许多次买卖的递推关系式：

dp[i][1] = max(dp[i - 1][1], prices[i] + dp[i - 1][0]);
dp[i][0] = max(dp[i - 1][0], dp[i-1][1]-prices[i]);
其中dp[i][1]表示第i天手上没有股票的最大利润
dp[i][0]表示第i天手上有股票的最大利润。

对于dp[i][1]表示第i天手上不持有股票的最大利润，在没有冷冻期时，我们只需要考虑股票是不是第i天卖出去的，然后取二者最大值即可，但是当有了冷冻期后，我们需要考虑导致用户手上不持有股票还有没有其他情况，很明显有，那就是如果第i天是冷冻期的话，那么第i天用户同样不会持有股票，此时的最大利润也需要进行比较求最大值，下面我们分析具体递推关系式：

根据上述分析可以将第i天的状态分为：
0：用户第i天持有股票（请时刻记住第i天持有或者不持有不代表是第i天买的或者卖的）
1：用户第i天不是冷冻期，并且不持有股票
2：用户第i天是冷冻期，不持有股票

首先我们分析状态0，第i天持有股票可能是第i天买的，也可能是i-1天就持有了股票，如果是第i天买的（此时第i-1天一定没有卖，如果卖了那么第i天就是冷冻期了），那么此时的利润为i-1天(此时手上不持有股票)的利润-prices[i]，i-1天用户不持有股票的利润不正是状态1和状态2吗，但是注意此时第i-1天一定不能为当天卖了股票的状态，但是状态1中包含两种情况，其中有一种状态就是当天卖了股票，因此需要对状态1进行进一步分解，最终用户第i天的状态如下：

将上述状态1分解成状态1、2
0：用户第i天持有股票
1：用户第i天不是冷冻期，并且不持有股票，同时股票不是第i天卖出去的
2：用户第i天卖出股票
3：用户第i天是冷冻期，不持有股票

即然知道了每种状态的含义，那么现在可以开始写出它们的递推关系式

首先分析状态0，dp[i][0] 表示第i天用户手上持有股票的最大利润，可以分为第i天买了股票和第i天没有买股票，第i天买了股票的最大利润就是
第i-1天不持有股票的利润-prices[i]
其中状态1、2、3均表示用户不持有股票，但是我们上面分析过要排除状态2，因此第i天买了股票的最大利润就是：
max(dp[i-1][1],dp[i-1][3])-prices[i]
同理第i天没买的最大利润就是i-1天用户手上持有股票的最大利润，即为：
dp[i-1][0]
根据上述分析便可以写出dp[i][0]的递推关系式：

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

接下来分析状态1，dp[i][1] 表示用户第i天不是冷冻期，并且不持有股票，同时股票不是第i天卖出去的最大利润，我们可以稍加分析，即然股票不是第i天卖的，那么一定是i-2天内卖的（因为第i-1天不会卖，卖了第i天就是冷冻期了），如果卖了，那么一定会有一天为冷冻期，我们以第i天是不是冷冻期来分解状态1，因此状态1可以分解为：
i-1天为冷冻期
i-1天不为冷冻期
如果第i-1天为冷冻期，即第i-1天为冷冻期，并且不持有股票，这不正是状态3吗，即为dp[i-1][3]。
如果第i-1天不为冷冻期，即第i-1天不为冷冻期，并且不持有股票，并且股票不是第i天卖出去的，这正是状态1，即为dp[i-1][1]。
因此dp[i][1]的递推关系式为：

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

接下来分析状态2，dp[i][2] 表示用户第i天卖出股票的利润，那么此时的利润就是i-1天手上持有股票的利润（状态0）-prices[i]。递推关系式如下：

dp[i][2] = dp[i - 1][0] + prices[i]

接下来分析状态3，dp[i][3] 表示用户第i天是冷冻期，不持有股票，第i天是冷冻期，那么第i-1天肯定当天卖出股票（状态2），故递推关系式为：

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][0] 表示第0天持有股票的最大利润，即为-prices[0].
dp[0][1]、dp[0][2]、dp[0][3]都是不持有股票的状态，将其看为当天买入卖出，那么初始化为0就行了。
这里对于初始值的理解其实有一定问题，应该需要结合递推关系式一起推理初始值。

最后要注意我们的返回值是什么，首先要知道最大利润一定是手上没有股票的状态，即状态1、2、3的最大值。

代码及运行结果

代码如下：

#include<iostream>
#include<vector>
#include <iomanip>
using namespace std;

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];
            cout << "第" << i << "天的结果：" << endl;
			for (int j = 0;j < 4;j++)
			{

				cout << std::left << setw(2) << dp[i][j] << "  ";
			}
			cout << endl << endl;
        }
        return max(dp[n - 1][3], max(dp[n - 1][1], dp[n - 1][2]));
    }
};

int main()
{
    vector<int> prices = { 1,2,3,0,2 };
    Solution s;
    cout << s.maxProfit(prices) << endl;
    return 0;
}

运行结果如下：

在这里插入图片描述

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

题目：
给定一个整数数组 prices，其中第 i 个元素代表了第 i 天的股票价格 ；非负整数 fee 代表了交易股票的手续费用。

你可以无限次地完成交易，但是你每笔交易都需要付手续费。如果你已经购买了一个股票，在卖出它之前你就不能再继续购买股票了。

返回获得利润的最大值。

注意：这里的一笔交易指买入持有并卖出股票的整个过程，每笔交易你只需要为支付一次手续费。

示例 1:

输入: prices = [1, 3, 2, 8, 4, 9], fee = 2
输出: 8
解释: 能够达到的最大利润:

在此处买入 prices[0] = 1
在此处卖出 prices[3] = 8
在此处买入 prices[4] = 4
在此处卖出 prices[5] = 9
总利润: ((8 - 1) - 2) + ((9 - 4) - 2) = 8.

思路分析

本题在思路上和122题类似，没有前面几道题这么复杂，因为此时用户的状态只有两种那就是持有股票和未持有股票，加入了手续费后唯一需要注意的就是现在卖出股票时需要减去这个手续费，所以很容易确定递推关系式如下：

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)
其中dp[i][0]表示第i天持有股票的最大利润，加入手续费并不影响买股票时的利润，因此和122题的递推关系式一样。
而dp[i][1]表示第i天未持有股票的最大利润，可以分为是第i天卖的股票和不是第i天卖的股票。
如果不是第i天卖的股票即第i-1天为未持有股票的状态。
如果是第i天卖的股票，则此时的利润为第i-1天持有股票的利润+prices[i]-手续费。
二者取最大值即为最终的递推关系式。

代码及运行结果

代码如下：

#include<iostream>
#include<vector>
#include <iomanip>
using namespace std;

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);
			cout << "第" << i << "天的两种利润：" << endl;
			cout << dp[i][0] << "  " << dp[i][1] << endl;
			cout << endl;
		}
		cout << "结果为：" << endl;
		return max(dp[n - 1][0], dp[n - 1][1]);
	}
};

int main()
{
	vector<int> prices = { 1, 3, 2, 8, 4, 9 };
	int fee = 2;
	Solution s;
	cout << s.maxProfit(prices, fee) << endl;
	return 0;
}

运行结果如下：

在这里插入图片描述

总结

以上就是我对买卖股票最佳时机相关问题的理解，尽量以最通俗的语言分析问题，主要防止自己对知识的遗忘，同时也希望对读者有所帮助。

haoooyee
关注
每日LeetCode——股票购买
qq_36776216的博客
08-24 607
121、 给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。 如果你最多只允许完成一笔交易（即买入和卖出一支股票），设计一个算法来计算你所能获取的最大利润。 注意你不能在买入股票前卖出股票。   public int maxProfit(int[] prices) { int max = 0; for (int i = 0; i &lt; prices.le...
LeetCode买卖股票的最佳时机系列总结
ChaseHeart的博客
08-26 400
LeetCode买卖股票的最佳时机系列总结 此类动态规划从二维动规理解后优化到一维动规，部分题目还可以用到贪心。 目录： 121 买卖股票的最佳时机1 122 买卖股票的最佳时机2 123 买卖股票的最佳时机3 188 买卖股票的最佳时机4 309 买卖股票的最佳时机+冷冻期 714 买卖股票的最佳时机+手续费（2的基础上卖出时-手续费） 121 买卖股票的最佳时机（买卖一次） 给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。 你只能选择 某一天 买入
LeetCode刷题—股票交易问题
qq_39181839的博客
03-11 538
再做一次股票交易问题，又发现满满的套路，跟我一起重刷一遍吧！思路清晰！一口气狂撸6道题！ 题目汇总： 贪心 121，最多进行一次买卖 122，可以多次买卖 二维DP 122，可以多次买卖 309，多次买卖+卖出冷冻期 714，多次买卖+卖出手续费 三维DP 123，最多两次买卖 188，最多 k 次买卖 注意卖出必须在买入之后！ 【贪心】 121，买卖股票的最佳时机，easy 给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。 如果你最多只允许完成一笔交易（即买入和卖出一支股
【NO.8】LeetCode经典150题-122. 买卖股票的最佳时机 II
最新发布
wang_luwei的博客
08-24 356
例如，题目中的例子 [1,2,3,4,5]，数组的长度 n=5，按照贪心的逻辑，交易过程是进行 4 次买入和 4 次卖出，但实际上买卖操作时是在第 1 天买入，第 5 天卖出。解释：在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5 - 1 = 4。随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6 - 3 = 3。输入：prices = [1,2,3,4,5]
Leetcode 股票交易
humanleelxy的博客
12-19 556
股票交易系列共有三道题目，难度递增。 1题 Say you have an array for which the ith element is the price of a given stock on day i. If you were only permitted to complete at most one transaction (ie, buy one and sell
Leetcode 买卖股票
一只老风铃
05-22 424
题目描述 假设你有一个数组，其中第i个元素是某只股票在第i天的价格。 设计一个算法来求最大的利润。你最多可以进行两次交易。 注意: 你不能同时进行多个交易(即，你必须在再次购买之前出售之前买的股票)。 示例1 输入 复制 [1,4,2] 输出 复制 3 思路：采取四个变量记录买入卖出 buy1 sell1 buy2 sell2 假设你现在手里的钱数为0。 buy1，记录的是在从第1天到第i天你能买到的最低价格（买了，所以欠账，所以记录为负数，所以用max）， sel...
leetcode 股票系列 121, 122, 123, 309, 118，714（dp）
rudychan的博客
08-29 236
leetcode121 ez: 题目：一次交易（找出最大差值） 做法：最小值记录到目前为止的最小值，res记录到目前为止最大利润。遍历一遍找到最大值。 class Solution { public int maxProfit(int[] prices) { int min=Integer.MAX_VALUE; int res=0; fo...
leetcode 买卖股票的最佳时机 II java
01-06
你可以尽可能地完成更多的交易（多次买卖一支股票）。 注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。 示例 1: 输入: [7,1,5,3,6,4] 输出: 7 解释: 在第 2 天（股票价格 = 1）的时候买入，...
LeetCode：121.买卖股票的最佳时机——动态规划
Super algorithm 的博客，技术爱好者。
03-29 2797
121. 买卖股票的最佳时机(1、2)——动态规划、贪心策略 给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。 你只能选择**某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票**。设计一个算法来计算你所能获取的最大利润。 返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。 🍎道阻且长，行则将至。🍓！！！
【leetcode买卖股票系列问题】多次买卖/手续费/冻结期
燕大Java第一深情的博客
08-22 1890
【leetcode买卖股票系列问题】多次买卖/手续费/冻结期，对于股票问题的汇总，希望日后再看的时候有新的理解吧！
LeetCode122买卖股票的最佳时机II
01-07
你可以尽可能地完成更多的交易（多次买卖一支股票）。 注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。 示例 1: 输入: [7,1,5,3,6,4] 输出: 7 解释: 在第 2 天（股票价格 = 1）的时候买入，...
LeetCode-股票系列
qq_38977067的博客
12-23 166
LeetCode-股票系列 相关题目有： 121.买卖股票的最佳时机（剑指Offer63）-- 简单、中等 122.买卖股票的最佳时机Ⅱ – 简单 123.买卖股票的最佳时机Ⅲ – 困难 188.买卖股票的最佳时机Ⅳ – 困难 309.最佳买卖股票时机含冷冻期 – 中等 714.买卖股票的最佳时机含手续费 – 中等 题目描述 给定一个数组，它的第 iii 个元素是一支给定股票第 iii 天的价格。 如果你最多只允许完成一笔交易（即买入和卖出一支股票一次），设计一个算法来计算你所能获取的最大利润。 注意：你不
LeetCode股票题
fruit513的博客
03-14 217
121.https://leetcode.com/problems/best-time-to-buy-and-sell-stock/ 只能买卖一次，先买后卖 先做差值，然后相当于求最大连续子数组 public int maxProfit(int[] prices) { int sum = 0; int max = 0; for(int i = 1; ...
leetcode-动态规划【股票问题】
SunYutong_1234的博客
04-25 318
今天基金又亏了，浅做一下买卖股票问题假装赚了钱
leetcode股票问题
chuxuezheerer的博客
03-16 198
1.(121) 买卖股票的最佳时机I 2.（122)买卖股票的最佳时机 II 3.(309)最佳买卖股票时机含冷冻期 4.(714) 买卖股票的最佳时机含手续费 5.（123） 买卖股票的最佳时机 III 6.(188) 买卖股票的最佳时机 IV
leetcode 121.Best Time to Buy and Sell Stock 股票买卖最佳时间
编程小白小卿的博客
03-13 1279
题目： Say you have an array for which the ith element is the price of a given stock on day i. If you were only permitted to complete at most one transaction (ie, buy one and sell one share of the
Leetcode由浅入深（二），炒股票系列
nmslhjyz的博客
02-07 333
在Leetcode中，有这么一类基于某些场景的问题，虽然归根到底也是算法，但是却给枯燥的算法带来了些许的活力。那么，我们就来看一下，Leetcode中最经典的实际应用题——炒股票 一、Best Time to Buy and Sell Stock 题目的大意是你是个股民，然后你还有预知未来的能力，于是你通过这个能力得知了之后每天股票的价格，你可以从任意一天买入股票，也可以在任意一天卖掉，但是你
《LeetCode》—— 买卖股票的最佳时机
m0_56069910的博客
05-16 2605
动态规划题目的讲解
Leetcode 股票问题集合
JehanRio's Private Blog
05-07 1522
这里着重提醒一下，时刻牢记「状态」的定义，状态 k 的定义并不是「已进行的交易次数」，而是「最大交易次数的上限限制」。如果确定今天进行一次交易，且要保证截至今天最大交易次数上限为 k，那么昨天的最大交易次数上限必须是 k - 1。然后我今天选择 rest，所以我今天还是没有持有，最大交易次数限制依然为 k。但是今天我 sell 了，所以我今天没有持有股票了，最大交易次数限制依然为 k。但今天我选择 buy，所以今天我就持有股票了，最大交易次数限制为 k。记得更新minprice。
买卖股票的最佳时机是区间动态规划算法嘛
07-25
根据引用\[1\]和引用\[2\]的内容，买卖股票的最佳时机可以使用动态规划算法来解决。动态规划是一种通过将问题分解为子问题并利用子问题的解来求解原问题的方法。在这个问题中，我们可以定义一个状态数组dp，其中dp\[i\]表示第i天卖出股票所能获得的最大利润。然后，我们可以通过遍历价格数组prices，计算出每一天卖出股票所能获得的最大利润，并更新dp数组。最后，dp数组中的最后一个元素即为所求的最大利润。 根据引用\[3\]的内容，区间动态规划算法是解决买卖股票的最佳时机问题的一种方法。在这个算法中，我们需要考虑每个可能的买入和卖出的时间点，并计算出每个时间点的最大利润。然后，我们可以通过比较这些最大利润，找到最大的利润作为结果。 所以，买卖股票的最佳时机可以使用区间动态规划算法来解决。 #### 引用[.reference_title] - *1* *3* [【算法-LeetCode】121. 买卖股票的最佳时机（动态规划；贪心）](https://blog.csdn.net/qq_44879358/article/details/120306943)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control_2,239^v3^insert_chatgpt"}} ] [.reference_item] - *2* [【算法-LeetCode】122. 买卖股票的最佳时机 II（动态规划；贪心）](https://blog.csdn.net/qq_44879358/article/details/120783546)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control_2,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值