买卖股票的最佳时机 I II III IV动态规划 C++

优秀解答： https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-iii/solution/yi-ge-tong-yong-fang-fa-tuan-mie-6-dao-gu-piao-wen/
不可重复购买，非动态规划 ，维持两个变量，一个是之前的最小值（高买低卖），一个是得到的最大的返回值。

int maxProfit(vector<int>& prices)
{
    if (prices.size() == 0 || prices.size() == 1)
        return 0;
    int min_num = prices[0];
    int fee = 0;
    for (int i = 1; i < prices.size(); i++)
    {
        if (prices[i] > min_num)
        {
            fee = max(fee, prices[i] - min_num);
        }
        else
            min_num = min(min_num, prices[i]);
    }
    return fee;
}

可重复购买，只要比

int maxProfit(vector<int>& prices) {
	int count = 0;
	for (int i = 0; i<int(prices.size()) - 1; i++)
	{
		count = count + (prices[i + 1] > prices[i] ? prices[i + 1] - prices[i] : 0);
	}
	return count;
}

动态规划：

一道状态图：
假设就买一次：
假设现在为不持有股票的状态，当天所能得到的最大收益，就是上一天不持股，或者上一天持股今天卖 中间的最大值。
写出状态方程
设K为买卖的次数。则

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

得到状态转移方程组。
当k为0时，所有的买卖dp都为0
那么 可以改写为

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

由于k=1时，所有的都为1，可以把1剔除，又可以改写为

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

所以得到代码：

int maxProfit(vector<int>& prices) {
	if (prices.size() == 0 || prices.size() == 1)
		return 0;
	vector<vector<int>> dp(prices.size(), { 0,0 });
	dp[0][0] = 0;
	dp[0][1] = -prices[0];
	for (int i = 1; i < prices.size(); i++)
	{
		dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] + prices[i]);

		dp[i][1] = max(dp[i - 1][1], - prices[i]);
		cout << dp[i][0] <<" "<< dp[i][1] << endl;
	}
	return dp[prices.size() - 1][0];
}

这时候发现 dp[i-1][0] dp[i-1][1]只用到这里按个数。继续改写：

int maxProfit(vector& prices) {

    if (prices.size() == 0 || prices.size() == 1)
        return 0;
    /*dp[0][0] = 0;
    dp[0][1] = -prices[0];*/
    int dp_i1_0 = 0;
    int dp_i1_1 = -prices[0];
    for (int i = 1; i < prices.size(); i++)
    {
        int temp = dp_i1_1;
        dp_i1_0 = max(dp_i1_0, dp_i1_1 + prices[i]);
        dp_i1_1 = max(dp_i1_1, -prices[i]);
    }
    return dp_i1_0;
}

其实就相当于 第一次，总是由第0次推广而来。

而买卖不限定次数，则不需要推广。

 int maxProfit(vector<int>& prices) {
    if (prices.size() == 0 || prices.size() == 1)
        return 0;
    /*dp[0][0] = 0;
    dp[0][1] = -prices[0];*/
    int dp_i1_0 = 0;
    int dp_i1_1 = -prices[0];
    for (int i = 1; i < prices.size(); i++)
    {
        int temp = dp_i1_0;
    
        dp_i1_0 = max(dp_i1_0, dp_i1_1 + prices[i]);
        dp_i1_1 = max(dp_i1_1, temp -prices[i]);
    }
    return dp_i1_0;
}

注意这句 dp_i1_1 = max(dp_i1_1, temp -prices[i]); 这句话的意思就是 不管 我买卖几次，要么我之前没卖，要么我现在买了买了。

买卖K次，由于之前1是由0推广，而K为无穷大的时候 干脆不推广 并没有用到K的值，当限定买卖K次的时候，就需要 对K讨论了。下面就是K次买卖了。

int maxProfit(vector<int>& prices, int kk) {
	if (prices.size() == 0 || prices.size() == 1)
		return 0;
	vector<vector<vector<int>>>dp(prices.size(), vector<vector<int>>(kk+1, { 0,0 }));//三维数组
	for (int i = 0; i < kk+1; i++)
	{
		dp[0][i][0] = 0;
		dp[0][i][1] = -prices[0];
	}
	 for (int i = 1; i < prices.size(); i++)
	{
		 for (int k = 1; k<=kk ; k++)
		{
			dp[i][k][0] = max(dp[i - 1][k][0], dp[i - 1][k][1] + prices[i]);
	
			dp[i][k][1] = max(dp[i - 1][k][1], dp[i - 1][k - 1][0] - prices[i]);//这地方涉及到k-1

		}
	}
	return dp[prices.size() - 1][kk][0];
}

加限制条件 系列，T+2限制，当天卖过后天才能买

int maxProfit(vector<int>& prices) {
	if (prices.size() == 0 || prices.size() == 1)
		return 0;
	int dp_i2_0 = 0;//第0天不持有收益，空仓
	int dp_i2_1 = -prices[0];//第0天，持有收益，一定是买了
	int dp_i1_0 = max(0, prices[1] - prices[0]);//第1天不持有收益，可能是没买或者买了又卖了
	int dp_i1_1 = max(-prices[0], -prices[1]);//第1天持有，可能是第0天买了或者第一天买了
	for (int i = 2; i < prices.size(); i++) {
		int temp = dp_i1_0;
		dp_i1_0 = max(dp_i1_0, dp_i1_1 + prices[i]);//状态方程，第n天不持有，可能前一天卖，或者前一天空仓
		dp_i1_1 = max(dp_i1_1, dp_i2_0 - prices[i]);//状态方程，第n天持有， 课程前一天持有，或者大前天卖了今天又买了
		dp_i2_0 = temp;
	}
	return dp_i1_0;
}

加限制系列，卖出需要收取一定的手续费

int maxProfit(vector<int>& prices,int fee) {
	if (prices.size() == 0 || prices.size() == 1)
		return 0;
	int dp_i1_0 = 0;
	int dp_i1_1 = -prices[0];
	for (int i = 1; i < prices.size(); i++)
	{
		int temp = dp_i1_0;
		dp_i1_0 = max(dp_i1_0, dp_i1_1 + prices[i]-fee);
		dp_i1_1 = max(dp_i1_1, temp - prices[i]);
	}
	return dp_i1_0;
}

求k 次操作 ，当k大于prices.size()/2时,那么就退化成无限次操作。

int maxProfit(vector<int>& prices) {
	if (prices.size() == 0 || prices.size() == 1)
		return 0;
	int dp_i1_0 = 0;
	int dp_i1_1 = -prices[0];
	for (int i = 1; i < prices.size(); i++)
	{
		int temp = dp_i1_0;

		dp_i1_0 = max(dp_i1_0, dp_i1_1 + prices[i]);
		dp_i1_1 = max(dp_i1_1, temp - prices[i]);
	}
	return dp_i1_0;
}

int maxProfit(int k, vector<int>& prices) {
	if (prices.size() == 0 || prices.size() == 1)
		return 0;
	if (k > prices.size() >> 1)
		return maxProfit(prices);
	int kk = k;
	vector<vector<vector<int>>>dp(prices.size(), vector<vector<int>>(kk + 1, { 0,0 }));//三维数组
	for (int i = 0; i < kk + 1; i++)
	{
		dp[0][i][0] = 0;
		dp[0][i][1] = -prices[0];
	}
	for (int i = 1; i < prices.size(); i++)
	{
		for (int k = 1; k <= kk; k++)
		{
			dp[i][k][0] = max(dp[i - 1][k][0], dp[i - 1][k][1] + prices[i]);
			dp[i][k][1] = max(dp[i - 1][k][1], dp[i - 1][k - 1][0] - prices[i]);//这地方涉及到k-
		}
	}
	return dp[prices.size() - 1][kk][0];
}