动态规划：买卖股票系列

华科大胡子

于 2024-08-06 17:08:45 发布

阅读量1.4k

点赞数 52

分类专栏：算法文章标签：动态规划算法买卖股票

本文链接：https://blog.csdn.net/weixin_39549734/article/details/140891934

版权

算法专栏收录该内容

3 篇文章 0 订阅

订阅专栏

1. 买卖股票的最佳时机1-只能买卖一次(LeetCode121)

解法1：暴力解法

解法2：贪心算法

解法3：动态规划

2. 买卖股票的最佳时机2-可以买卖多次(LeetCode122)

解法1：贪心算法

解法2：动态规划

3. 买卖股票的最佳时机3-最多买卖两次(LeetCode123)

4. 买卖股票的最佳时机4-最多买卖k次(LeetCode188)

5. 买卖股票的最佳时机含冷冻期-买卖多次，卖出有一天冷冻期(LeetCode309)

6. 买卖股票的最佳时机含手续费-买卖多次，每次有手续费(LeetCode714)

前言：

所有的股票问题 都可以使用动态规划来求解（动态规划是求解股票问题的正规解法）
部分的股票问题 可以使用贪心算法来求解（贪心往往比动态规划更巧妙更好用，但是贪心只能解决部分场景）

1. 买卖股票的最佳时机1-只能买卖一次(LeetCode121)

题目描述：https://leetcode.cn/problems/best-time-to-buy-and-sell-stock/description/

解法1：暴力解法

解题思路：

第一层for循环：遍历买股票的位置（区间起点）
第二层for循环：遍历卖股票的位置（区间终点）

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

class Solution
{
public:
    int maxProfit(vector<int>& prices)
    {
        int result = 0;
        // 第一层for循环：遍历买股票的位置（区间起点）
        for (int i = 0; i < prices.size(); i++)
        {
            // 第二层for循环：遍历卖股票的位置（区间终点）
            for (int j = i + 1; j < prices.size(); j++)
            {
                result = max(result, prices[j] - prices[i]);  // 打擂法求最大值
            }
        }
        return result;
    }
};

int main()
{
    //vector<int> prices{ 7,1,5,3,6,4 };  // 5
    vector<int> prices{ 7,6,4,3,1 };  // 0

    Solution s;
    int ans = s.maxProfit(prices);

    cout << ans << endl;

    system("pause");
    return 0;
}

复杂度分析：

时间复杂度：O(n^2) LeetCode提交超时
空间复杂度：O(1) 无需额外的辅助空间

解法2：贪心算法

解题思路：由于股票就买卖一次，因此贪心思路为"取最左最小值，取最右最大值"，得到的差值就是最大利润。

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

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

int main()
{
	vector<int> prices{ 7,1,5,3,6,4 };  // 5
	//vector<int> prices{ 7,6,4,3,1 };  // 0

	Solution s;
	int ans = s.maxProfit(prices);

	cout << ans << endl;

	system("pause");
	return 0;
}

复杂度分析：

时间复杂度：O(n) 需要从前向后遍历prices数组
空间复杂度：O(1) 需要辅助变量low，为常数级的空间

解法3：动态规划

解题思路：动态规划五部曲

Step1：确定dp数组(一维)/dp表格(二维)、下标的含义
dp[i][0]：第i天不持有股票，所得最多现金
注意：第i天不持有股票，并不表示第i天一定卖出股票，有可能是前面卖出股票，第i天仅仅是维持卖出股票的状态
dp[i][1]：第i天持有股票，所得最多现金
注意：第i天持有股票，并不表示第i天一定买入股票，有可能是前面买入股票，第i天仅仅是维持买入股票的状态
Step2：确定递推公式
dp[i][0]：第i天不持有股票可以由两个状态推导出来
第i-1天不持有股票，第i天保持现状 → 所得现金就是昨天不持有股票的所得现金 dp[i - 1][0]
第i-1天持有股票，第i天卖出股票 → 所得现金就是按照今天股票价格卖出后所得现金 dp[i - 1][1] + prices[i]
dp[i][1]：第i天持有股票可以由两个状态推导出来
第i-1天不持有股票，第i天买入股票 → 所得现金就是买入今天的股票后所得现金 dp[i-1][0]-prices[i] → -prices[i]
由于本题的限制条件为买卖一次，第i天买入股票表明前面均不能买入，因此前面不会有任何收益，即dp[i-1][0]=0
第i-1天持有股票，第i天保持现状 → 所得现金就是昨天持有股票的所得现金 dp[i-1][1]
Step3：初始化dp数组
从递推公式可以看出，i是由i-1推导而来，因此需要初始化第一个元素
dp[0][0]：第0天不持有股票，所得最多现金为0
dp[0][1]：第0天持有股票（表明买入股票），所得最多现金为-prices[0]
Step4：确定遍历顺序
从递推公式可以看出，i是由i-1推导而来，因此需要从前向后遍历
Step5：打印dp数组（调试）

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

class Solution
{
public:
    int maxProfit(vector<int>& prices) 
    {
        // Step3：初始化dp数组
        vector<vector<int>> dp(prices.size(), vector<int>(2,0));
        dp[0][0] = 0;
        dp[0][1] = -prices[0];

        // Step4：确定遍历顺序
        for (int i = 1; i < prices.size(); i++)
        {
            // Step2：确定递推公式
            dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] + prices[i]);
            dp[i][1] = max(-prices[i], dp[i - 1][1]);
        }
        return dp[prices.size() - 1][0]; // 不持有股票状态 一定比 持有股票状态 所得金钱多
    }
};

int main()
{
    //vector<int> prices{ 7,1,5,3,6,4 };  // 5
    vector<int> prices{ 7,6,4,3,1 };  // 0

    Solution s;
    int ans = s.maxProfit(prices);

    cout << ans << endl;

    system("pause");
    return 0;
}

手动模拟dp数组的执行过程：prices = [ 7,1,5,3,6,4 ]
dp[i][0] dp[i][1]
i=0 0 -7
i=1 0 -1
i=2 4 -1
i=3 4 -1
i=4 5 -1
i=5 5 -1

2. 买卖股票的最佳时机2-可以买卖多次(LeetCode122)

题目描述：https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-ii/description/

题目简述：

允许多次买卖
任何时候最多只能持有一股股票（即必须在再次购买前出售掉之前的股票）

解法1：贪心算法

解题思路：

收集每天的正利润(局部最优) → 最大利润(全局最优)
收集正利润的区间 → 股票买卖的区间（非题目要求，并不关心哪一天买入，哪一天卖出）

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

class Solution {
public:
    int maxProfit(vector<int>& prices) 
    {
        // Step0：定义变量（准备工作）
        int max_profit = 0;     // 存储最终结果（最大利润）
        int cur_profit = 0;     // 存储每天的正利润

        for (int i = 1; i < prices.size(); i++)
        {
            // Step1：计算每天的正利润
            cur_profit = prices[i] - prices[i - 1];

            // Step2：更新最终结果  三种方式（由简到难）
            max_profit += max(cur_profit, 0);            // max操作   
            // max_profit += cur_profit > 0 ? cur_profit : 0;   // 三目运算符
            // if (cur_profit > 0) max_profit += cur_profit;    // if语句
        }
        return max_profit;
    }
};

int main()
{
    vector<int> prices{ 7,1,5,3,6,4 };
    //vector<int> prices{ 1,2,3,4,5 };
    //vector<int> prices{ 7,6,4,3,1 };

    Solution s;
    int ans = s.maxProfit(prices);

    cout << ans << endl;

    system("pause");
    return 0;
}

示例1(非单调)： 7 1 5 3 6 4
正利润： -6 4 -2 3 -2 → 最大利润为4+3=7
正利润区间： [1,2] [3,4] → [1,2]表示第1天买入，第2天卖出（天数从0开始计数）
买卖方式：第1天买入，第2天卖出；第3天买入，第4天卖出此时可以获得最大利润

示例2(单调递增)： 1 2 3 4 5
正利润： 1 1 1 1 → 最大利润为1+1+1+1=4
正利润区间： [0,1] [1,2] [2,3] [3,4]
买卖方式1：第0天买入，第1天卖出；第1天买入，第2天卖出；第2天买入，第3天卖出；第3天买入，第4天卖出此时可以获得最大利润
买卖方式2(合并连续区间)：第0天买入，第4天卖出此时可以获得最大利润

示例3(单调递减)： 7 6 4 3 1
正利润： -1 -1 -1 -2 → 最大利润为0
正利润区间：无
买卖方式：不参与交易

复杂度分析：

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

注意事项：

易错点1：max_profit初始化为0？还是初始化为INT_MIN？
max_profit应该初始化0，此时即便没有参与交易，利润应该为0，而不是负无穷
易错点2：i从0开始？还是从1开始？
i应该从1开始，因为第0天没有利润，至少要第1天才会有利润，正利润的序列比股票序列少一天！

解法2：动态规划

解题思路：

Step1：确定dp数组(一维)/dp表格(二维)、下标的含义
dp[i][0]：第i天不持有股票，所得最多现金
dp[i][1]：第i天持有股票，所得最多现金
Step2：确定递推公式
dp[i][0]：第i天不持有股票可以由两个状态推导出来
第i-1天不持有股票，第i天保持现状 → 所得现金就是昨天不持有股票的所得现金 dp[i - 1][0]
第i-1天持有股票，第i天卖出股票 → 所得现金就是按照今天股票价格卖出后所得现金 dp[i - 1][1] + prices[i]
dp[i][1]：第i天持有股票可以由两个状态推导出来
第i-1天不持有股票，第i天买入股票 → 所得现金就是买入今天的股票后所得现金 dp[i-1][0]-prices[i]
注意：这是本题与"买卖股票的最佳时机-只能买卖一次"的唯一区别（买入股票时，可能会有之前买卖的利润）
由于本题能够买卖多次，尽管第i-1天不持有股票，但是前面仍然可能发生过交易，导致前面可能会产生收益，即dp[i-1][0]不一定等于0
第i-1天持有股票，第i天保持现状 → 所得现金就是昨天持有股票的所得现金 dp[i-1][1]
Step3：初始化dp数组
从递推公式可以看出，i是由i-1推导而来，因此需要初始化第一个元素
dp[0][0]：第0天不持有股票，所得最多现金为0
dp[0][1]：第0天持有股票（表明买入股票），所得最多现金为-prices[0]
Step4：确定遍历顺序
从递推公式可以看出，i是由i-1推导而来，因此需要从前向后遍历
Step5：打印dp数组（调试）

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

class Solution
{
public:
	int maxProfit(vector<int>& prices)
	{
        vector<vector<int>> dp(prices.size(), vector<int>(2, 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][0] - prices[i], dp[i - 1][1]);  // 唯一区别
        }
        return dp[prices.size() - 1][0];  // 不持有股票状态 一定比 持有股票状态 所得金钱多
	}
};

int main()
{
    vector<int> prices{ 1,2,3,4,5 };  // 4
    //vector<int> prices{ 7,6,4,3,1 };  // 0

    Solution s;
    int ans = s.maxProfit(prices);

    cout << ans << endl;

	system("pause");
	return 0;
}

复杂度分析：

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

3. 买卖股票的最佳时机3-最多买卖两次(LeetCode123)

题目描述：https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-iii/description/

解题思路：动态规划五部曲

Step1：确定dp数组(一维)/dp表格(二维)、下标的含义
dp[i][0]：第i天 没有操作，所得最多现金（也可以不设置这个状态）
dp[i][1]：第i天 第一次持有股票，所得最多现金
dp[i][2]：第i天 第一次不持有股票，所得最多现金
dp[i][3]：第i天 第二次持有股票，所得最多现金
dp[i][4]：第i天 第二次不持有股票，所得最多现金
Step2：确定递推公式
dp[i][0]：第i天没有操作
第i-1天没有操作，第i天保持前一天的状态 → dp[i - 1][0]
dp[i][1]：第i天第一次持有股票
第i-1天没有操作，第i天第一次买入股票 → dp[i-1][0]-prices[i]
第i-1天第一次持有股票，第i天保持前一天的状态 → dp[i-1][1]
dp[i][2]：第i天第一次不持有股票
第i-1天第一次持有股票，第i天第一次卖出股票 → dp[i-1][1]+prices[i]
第i-1天第一次不持有股票，第i天保持前一天的状态 → dp[i-1][2]
dp[i][3]：第i天第二次持有股票
第i-1天第一次不持有股票，第i天第二次买入股票 → dp[i-1][2]-prices[i]
第i-1天第二次持有股票，第i天保持前一天的状态 → dp[i-1][3]
dp[i][4]：第i天第二次不持有股票
第i-1天第二次持有股票，第i天第二次卖出股票 → dp[i-1][3]+prices[i]
第i-1天第二次不持有股票，第i天保持前一天的状态 → dp[i-1][4]
Step3：初始化dp数组
从递推公式可以看出，i是由i-1推导而来，因此需要初始化第一个元素
dp[0][0]：第0天没有操作，所得最多现金为0
dp[0][1]：第0天第一次持有股票（表明买入股票），所得最多现金为-prices[0]
dp[0][2]：第0天第一次不持有股票（表明买入股票再卖出股票），所得最多现金为0（当天买入，当天卖出）
dp[0][3]：第0天第二次持有股票（表明买入股票再卖出股票，第二次买入股票），所得最多现金为-prices[0]
dp[0][4]：第0天第二次不持有股票（表明买入股票再卖出股票，第二次买入股票再卖出股票），所得最多现金为0
Step4：确定遍历顺序
从递推公式可以看出，i是由i-1推导而来，因此需要从前向后遍历
Step5：打印dp数组（调试）

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

class Solution
{
public:
	int maxProfit(vector<int>& prices)
	{
		vector<vector<int>> dp(prices.size(), vector<int>(5, 0));
		dp[0][0] = 0;
		dp[0][1] = -prices[0];
		dp[0][2] = 0;
		dp[0][3] = -prices[0];
		dp[0][4] = 0;

		for (int i = 1; i < prices.size(); i++)
		{
			dp[i][0] = dp[i - 1][0];
			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]);
			dp[i][4] = max(dp[i - 1][3] + prices[i], dp[i - 1][4]);
		}
		return dp[prices.size() - 1][4];
	}
};

int main()
{
	vector<int> prices{ 3,3,5,0,0,3,1,4 };  // 6
	//vector<int> prices{ 1,2,3,4,5 };  // 4
	//vector<int> prices{ 7,6,4,3,1 };    // 0

	Solution s;
	int ans = s.maxProfit(prices);

	cout << ans << endl;

	system("pause");
	return 0;
}

示例：prices = [ 3,3,5,0,0,3,1,4 ]
不操作第一次持有第一次不持有第二次持有第二次不持有
0 1 2 3 4
i=0 0 -3 0 -3 0
i=1 0 -3 0 -3 0
i=2 0 -3 2 -3 2
i=3 0 0 2 2 2
i=4 0 0 2 2 2
i=5 0 0 3 2 5
i=6 0 0 3 2 5
i=7 0 0 4 2 6

4. 买卖股票的最佳时机4-最多买卖k次(LeetCode188)

题目描述：https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-iv/description/

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

class Solution 
{
public:
    int maxProfit(int k, vector<int>& prices) 
    {
        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 = 1; j <= 2 * k; j += 2)
            {
                dp[i][j] = max(dp[i - 1][j - 1] - prices[i], dp[i - 1][j]);     // 第i天 第j次持有股票
                dp[i][j + 1] = max(dp[i - 1][j] + prices[i], dp[i - 1][j + 1]); // 第i天 第j次不持有股票
            }
        }

        return dp[prices.size() - 1][2 * k];
    }
};

int main()
{
    vector<int> prices{ 2,4,1 };  // 2
    int k = 2;

    //vector<int> prices{ 3,2,6,5,0,3 };  // 7
    //int k = 2;

    Solution s;
    int ans = s.maxProfit(k, prices);

    cout << ans << endl;

    system("pause");
    return 0;
}

5. 买卖股票的最佳时机含冷冻期-买卖多次，卖出有一天冷冻期(LeetCode309)

题目描述：https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-with-cooldown/description/

题目简述：本题 = 买卖多次 + 冷冻期 → 相对于"买卖股票的最佳时机2(买卖多次)"，本题加上了一个冷冻期

解题思路：动态规划五部曲

Step1：确定dp数组(一维)/dp表格(二维)、下标的含义
dp[i][0]：第i天不持有股票（非冷冻期），所得最多现金
dp[i][1]：第i天不持有股票（冷冻期），所得最多现金
dp[i][2]：第i天持有股票，所得最多现金
持有股票 → 不持有股票（冷冻期） → 持有股票（非冷冻期） 每个状态只能有自身以及前一个状态推导得到（状态是环形的）
在不含冷冻期的买卖股票问题中，冷冻期和非冷冻期的状态统称为不持有股票的状态
Step2：确定递推公式
dp[i][0]：第i天不持有股票（非冷冻期）
第i-1天不持有股票（非冷冻期），第i天维持现状 → 所得现金就是昨天不持有股票(非冷冻期)的所得现金 dp[i - 1][0]
第i-1天不持有股票（冷冻期），第i天从冷冻期转变为非冷冻期 → 所得现金就是昨天不持有股票(冷冻期)的所得现金 dp[i - 1][1]
dp[i][1]：第i天不持有股票（冷冻期）
第i-1天持有股票，第i天卖出股票，转变为冷冻期 → 所得现金就是昨天持有股票的所得现金加上今天卖出股票所得现金 dp[i - 1][2]+prices[i]
注1：第i天的冷冻期 不能由 第i-1天的冷冻期推导得到，因为冷冻期只能持续一天
注2：第i天的冷冻期 只能由 第i-1天持有股票推导得到
dp[i][2]：第i天持有股票
第i-1天不持有股票（非冷冻期），第i天买入股票 → 所得现金就是昨天不持有股票(非冷冻期)的所得现金减去今天买入股票的所花现金 dp[i - 1][0]-prices[i]
第i-1天持有股票，第i天维持现状 → 所得现金就是昨天持有股票的所得现金 dp[i-1][2]
Step3：初始化dp数组
从递推公式可以看出，i是由i-1推导而来，因此需要初始化第一个元素
dp[0][0]：第0天不持有股票（非冷冻期），所得最多现金为0
dp[0][1]：第0天不持有股票（冷冻期），所得最多现金为0
dp[0][2]：第0天持有股票（表明买入股票），所得最多现金为-prices[0]
Step4：确定遍历顺序
从递推公式可以看出，i是由i-1推导而来，因此需要从前向后遍历
Step5：打印dp数组（调试）

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

class Solution 
{
public:
    int maxProfit(vector<int>& prices) 
    {
        if (prices.size() == 1) return 0;

        vector<vector<int>> dp(prices.size(), vector<int>(3, 0));
        dp[0][0] = 0;
        dp[0][1] = 0;
        dp[0][2] = -prices[0];

        for (int i = 1; i < prices.size(); i++)
        {
            dp[i][0] = max(dp[i - 1][0], dp[i - 1][1]);              // 不持有股票(非冷冻期)
            dp[i][1] = dp[i - 1][2] + prices[i];                     // 不持有股票（冷冻期）
            dp[i][2] = max(dp[i - 1][0] - prices[i], dp[i - 1][2]);  // 持有股票
        }

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

int main()
{
    vector<int> prices{ 1,2,3,0,2 };  // 3
    // vector<int> prices{ 1 };  // 0

    Solution s;
    int ans = s.maxProfit(prices);

    cout << ans << endl;

    system("pause");
    return 0;
}

6. 买卖股票的最佳时机含手续费-买卖多次，每次有手续费(LeetCode714)

题目描述：https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-with-transaction-fee/description/

题目简述：本题 = 买卖多次 + 手续费 → 相对于"买卖股票的最佳时机2(买卖多次)"，本题加上了一个手续费

解题思路：动态规划五部曲

Step1：确定dp数组(一维)/dp表格(二维)、下标的含义
dp[i][0]：第i天不持有股票，所得最多现金
dp[i][1]：第i天持有股票，所得最多现金
Step2：确定递推公式
dp[i][0]：第i天不持有股票可以由两个状态推导出来
第i-1天不持有股票，第i天保持现状 → 所得现金就是昨天不持有股票的所得现金 dp[i - 1][0]
第i-1天持有股票，第i天卖出股票 → 所得现金就是按照今天股票价格卖出后所得现金 dp[i - 1][1] + prices[i] - fee
注：需要在计算卖出操作的时候减去手续费（本题和"买卖股票的最佳时机2"的唯一区别）
dp[i][1]：第i天持有股票可以由两个状态推导出来
第i-1天不持有股票，第i天买入股票 → 所得现金就是买入今天的股票后所得现金 dp[i-1][0]-prices[i]
第i-1天持有股票，第i天保持现状 → 所得现金就是昨天持有股票的所得现金 dp[i-1][1]
Step3：初始化dp数组
从递推公式可以看出，i是由i-1推导而来，因此需要初始化第一个元素
dp[0][0]：第0天不持有股票，所得最多现金为0
dp[0][1]：第0天持有股票（表明买入股票），所得最多现金为-prices[0]
Step4：确定遍历顺序
从递推公式可以看出，i是由i-1推导而来，因此需要从前向后遍历
Step5：打印dp数组（调试）

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

class Solution 
{
public:
    int maxProfit(vector<int>& prices, int fee) 
    {
        vector<vector<int>> dp(prices.size(), vector<int>(2, 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] - fee);  // 唯一区别
            dp[i][1] = max(dp[i - 1][0] - prices[i], dp[i - 1][1]);
        }
        return dp[prices.size() - 1][0];
    }
};

int main()
{
    //vector<int> prices{ 1,3,2,8,4,9 };  // 8
    //int fee = 2;

    vector<int> prices{ 1,3,7,5,10,3 };  // 6
    int fee = 3;

    Solution s;
    int ans = s.maxProfit(prices, fee);

    cout << ans << endl;

    system("pause");
    return 0;
}