股票问题汇总

最新推荐文章于 2024-10-10 22:59:02 发布
最新推荐文章于 2024-10-10 22:59:02 发布
阅读量186 收藏
点赞数 1
文章标签： 算法 动态规划 贪心算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/huayaba/article/details/126850848
版权

文章目录

前言

买卖一次

买卖多次

买卖至多两次

买卖至多k次

含手续费买卖多次

冷冻期买卖多次

/*
	snowy,2022-9-14
	动态规划——股票买卖
	贪心的话是每一步可能有很多选择，但贪心直接只选择可能最优的一种.
	动态规划是列出所有选择后，然后从中选出实际上最优的结果，可将贪心看作动态规划的一种特例

	题目描述：每支股票第i天的交易金额为prices[i]，
			 买卖一次，买卖多次，买卖k次，含手续费买卖，有冻结期买卖等
			 多种交易方式，求交易股票的最大利润
*/

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

// 买卖一次 —— 贪心算法，即价格最低时买入，最高时卖出。（常规暴力算法，双重for循环也可）
int maxProfix_one(const vector<int>& Prices) {
	int len = Prices.size();
	int minum = INT_MAX;
	int maxnum = 0;		//最大利润最小值只能为0
	//int profix = 0;

	for (int i = 0; i < len; ++i) {
		minum = min(Prices[i], minum);
		maxnum = max(Prices[i] - minum, maxnum);
	}
	return maxnum;	
}

// 买卖一次 —— 动态规划
int maxProfix_dp_one(const vector<int>& Prices) {
	/*
	动规五部曲
	1. 确定dp数组的下标和含义
	2. 确定递归公式
	3. 初始化dp数组
	4. 确定遍历顺序
	5. 打印dp数组进行验证

	分析：
	后一天获得的利润取决于之间的状态， 
	
	dp数组和递推公式
	每日状态有两种，持有股票和不持有股票利润，则最大利润即是最后一天不持有股票时的最大利润
	dp[i][0] //第i天持有股票所得最多利润, 今天刚买入，-Prices[i], 之前就持有了为dp[][i - 1][0]
	dp[i][0] = max(dp[i - 1][0]， - Prices[i])

	dp[i][1] //第i天不持有股票所得最多利润， 今天卖出，为dp[i - 1][0] + Prices[i], 之前就没有，dp[i - 1][1]
	dp[i][1] = max(dp[i - 1][1]， dp[i - 1][0] + Prices[i])

	初始化：
	dp[0][0] -= -Prices[0];
	dp[0][1] = 0;

	遍历顺序，从前往后遍历

	返回结果：最后一天不持有股票获得利润最大
	*/
	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], -Prices[i]);
		dp[i][1] = max(dp[i - 1][0] + Prices[i], dp[i - 1][1]);
	}
	int ans = dp[len - 1][1];
	return ans;
}

// 买卖多次 —— 贪心算法,只要收集每天的正利润即可
int maxProfix_many(const vector<int>& Prices) {
	int len = Prices.size();
	int profix = 0;		//最大利润最小值只能为0

	for (int i = 0; i < len; ++i) {
		profix = max(Prices[i] -Prices[i - 1], 0);
	}
	return profix;
}

// 买卖多次 —— 动态规划
	/*
	分析：可以买卖多次，当天收益状态取决于前一天的买卖状态，动态规划

	*/
int maxProfix_dp_many(const vector<int>& Prices) {
	/*
	动态规划
	每日持有股票状态：持有和不持有
	持有：dp[i][0], 当天买入dp[i - 1][1] - Prices[i]，或者之前就有 dp[i - 1][0]
	dp[i][0] = max(dp[i - 1][1] - Prices[i], dp[i - 1][0])
	不持有：dp[i][1]， 当天卖出，dp[i - 1][0] + Prices[i]，或者之前就不持有dp[i -1][1]
	dp[i][1] = max(dp[i - 1][0] + Prices[i], dp[i -1][1])

	初始化：
	dp[0][0] -= -Prices[0];
	dp[0][1] = 0;

	遍历顺序，从前往后遍历

	返回结果：最后一天不持有股票的最大值
	*/

	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]);
		dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] + Prices[i]);
	}
	int ans = dp[len - 1][1];
	return ans;
}

// 买卖2次
int maxProfix_dp_2(const vector<int>& Prices) {
	/*
	每天买卖状态：共五种
		0：没有操作，无买卖，dp[i][0]
		dp[i][0] 

		1：第一次持有持有，dp[i][1]
			之前无买卖，然后第一次买入持有：dp[i-1][0] - prices[i]，
			延续前一天买入持有状态：dp[i - 1][1]
		dp[i][1] = max(dp[i-1][0] - prices[i], dp[i - 1][1]);

		2：第一次卖出不持有，dp[i][2]
			当天卖出第一次持有买入持有的股票，dp[i][2] = dp[i - 1][1] + prices[i]
			延续前一天第一次卖出不持有的状态， dp[i][2] = dp[i - 1][2]
		dp[i][2] = dp[i][2] = max(dp[i - 1][1] + prices[i], dp[i - 1][2])

		3：第二次买入持有，dp[i][3]
			第一次卖出后买入持有，dp[i - 1][2] - prices[i]
			或者延续之前的第二次买入持有，dp[i - 1][3]
		dp[i][3] = max(dp[i - 1][3], dp[i - 1][2] - prices[i]);

		4：第二次卖出不持有，dp[i][4]
			在第二次买入后卖出，dp[i - 1][3] + prices[i]
			延续之前的第二次卖出不持有，dp[i - 1][4]
		dp[i][4] = max(dp[i - 1][4], dp[i - 1][3] + prices[i]);
		
		初始化：
		dp[0][0] = 0；
		dp[0][1] = -prices[0];
		dp[0][2] = 0；// 当利润比0还小时就没有必要卖出
		dp[0][3] = -prices[0];
		dp[0][4] = 0；

		遍历顺序：后一天取决于前一天状态，则从前往后遍历

		返回结果：最后一天第二次不持有的状态，否则没必要第二次持有了
	*/

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

// 买卖k次
int maxProfix_dp_k(const vector<int>& Prices, const int& k) {
	/*
		买卖k次 共2*k + 1种状态
		除了0以外，偶数就是卖出不持有，奇数就是买入持有。，每次卖出买入持有状态跟前一次买入卖出持有状态有关
		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]);
		}

		初始化
		for (int j = 1; j < 2 * k; j += 2) {
			dp[0][j] = -prices[0];
		}
	*/
	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];
}

//带手续费买卖
int maxProfix_dp_fee(const vector<int>& Prices, const int& fee) {
	/*
	第i天持有股票，dp[i][0], 
		延续之前的股票，dp[i][0] = dp[i - 1][0], 
		之前不持有，今天买入股票， dp[i][0] = dp[i - 1][1] - Prices[i],
	dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] - prices[i]);

	第i天不持有股票，dp[i][1],
		延续之前的不持有：dp[i][1] = dp[i - 1][1]
		之前持有，今天卖出 dp[i][1] = dp[i - 1][0] - fee + Prices[i]
	dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] + prices[i] - 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]);


}


// 冻结期买卖
int maxProfix_dp_stop(const vector<int>& Prices) {
	/* 
	每天的股票持有状态
	0：状态一：买入持有股票状态（今天买入股票，或者是之前就买入了股票然后没有操作）：dp[i][0] 
		三种情况：
			没操作，延续昨天的买入持有状态：dp[i][0] = dp[i - 1][0]
			昨天冷冻期，今天买入：dp[i][0] = dp[i - 1][3] - prices[i]
			昨天过了冷冻期，今天买入：dp[i][0] = 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]);

	卖出不持有股票状态，这里就有两种卖出股票状态
		1：状态二：今天之前就卖出了股票：dp[i][1] 
				昨天卖出不持有，为冷冻期 dp[i - 1][3]
				昨天是延续的之前的不持有状态 ：dp[i][1]  = dp[i - 1][1]
			dp[i][1] = max(dp[i - 1][1], dp[i - 1][3]);

		2：状态三：今天卖出了股票：dp[i][2] 
			今天卖出股票，则必须是买入持有状态
			dp[i][2] = dp[i - 1][0] + prices[i];

	3：状态四：今天为冷冻期状态，但冷冻期状态不可持续，只有一天！dp[i][3] 
		昨天卖出：dp[i][3] = dp[i - 1][2];
		dp[i][3] = dp[i - 1][2];

	初始化：
	dp[0][0] = -prices[0]；	//买入持有
	dp[0][1]	//保持卖出
	dp[0][2] = 0	//今天卖出
	dp[0][3] = 0	//今天冷冻期，昨天卖出去了
	*/

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

void test01(const vector<int>& Prices) {
 	cout << "贪心算法" << endl;
	int profix = maxProfix_one(Prices);
	cout << "单次买卖股票最大利润为： " << profix << endl;

	cout << "动态规划" << endl;
	int dp_profix = maxProfix_dp_one(Prices);
	cout << "单次买卖股票最大利润为： " << dp_profix << endl;

	return;
}

void test02(const vector<int>& Prices) {
	//cout << "买卖多次" << endl;
	cout << "动态规划" << endl;
	int dp_profix = maxProfix_dp_many(Prices);
	cout << "多次买卖股票最大利润为： " << dp_profix << endl;

	return;
}

void test03(const vector<int>& Prices) {
	//cout << "买卖多次" << endl;
	cout << "动态规划" << endl;
	int dp_profix = maxProfix_dp_2(Prices);
	cout << "至多2次买卖股票最大利润为： " << dp_profix << endl;

	return;
}

void test04(const vector<int>& Prices, const int& k) {
	//cout << "买卖多次" << endl;
	cout << "动态规划" << endl;
	int dp_profix = maxProfix_dp_k(Prices, k);
	cout << "至多k次买卖股票最大利润为： " << dp_profix << endl;

	return;
}

void test05(const vector<int>& Prices) {
	//cout << "买卖多次" << endl;
	cout << "动态规划" << endl;
	int dp_profix = maxProfix_dp_stop(Prices);
	cout << "冷冻期多次买卖股票最大利润为： " << dp_profix << endl;

	return;
}

void test06(const vector<int>& Prices, const int& k) {
	//cout << "买卖多次" << endl;
	cout << "动态规划" << endl;
	int dp_profix = maxProfix_dp_fee(Prices, k);
	cout << "至多k含手续费多次买卖股票最大利润为： " << dp_profix << endl;

	return;
}


int main() {

	vector<int> Prices = { 1, 3, 2, 8, 4, 9 };
	int k = 2;
	test01(Prices);
	test02(Prices);
	test03(Prices);
	test04(Prices, k);
	test05(Prices);
	int fee = 2;
	test06(Prices, fee);
	system("pause");
	return 0;
}
时是石头
关注
股票日线数据汇总共计17年，量化初始数据
01-31
这个名为“股票日线数据汇总共计17年”的压缩包显然包含了丰富的股票交易信息，是进行量化投资策略研究和构建神经网络预测模型的基础。下面将详细讨论这些知识点。 首先，我们来看“股票日线数据”（Day Data）。在...
我的股票交易系统汇总2019.xlsx
12-03
交易指标
Leetcode——买卖股票问题汇总
Michael_Jay的博客
12-14 1538
本篇文章汇总了股票买卖的五种问题，采取动态规划算法循序渐进解题。
股票问题汇总（待总结）
无问西东的博客
12-08 155
LeetCode股票问题汇总
StephenYou的自习室
08-26 638
目录 LeetCode股票问题汇总 问题描述 思路分析 穷举框架 状态转移框架 股票问题秒杀 Problem 1 Problem 2 Problem 3 Problem 4 Problem 5 LeetCode股票问题汇总 在刷LeetCode时碰到了股票买卖的系列问题，本质上他们的解法都可以用状态机动态规划的解法进行求解，在这里总结一下。 本篇文章借鉴了一个方法...
LeetCode上买卖股票问题汇总
smilejiasmile的博客
02-02 462
本文对LeetCode中的买卖股票问题做了一个汇总。
【LeetCode-面试-股票问题】算法中所有股票问题汇总
A-Itfuture的博客
12-22 819
  股票问题是我们常见的算法问题，因为它可以考察我们对算法的理解以及我们的编程思维方式，同时它也是贪心算法跟动态规划的高度体现！下面是LeetCode上面所有的股票问题！ 121.买卖股票的最佳时机（easy）限定交易次数 k=1 原题： 给定一个数组 prices ，它的第i个元素prices[i] 表示一支给定股票第 i 天的价格。 你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。 返回你可以从这笔交易中获取的最大利润。如果你不能获
力扣股票买卖问题汇总
lightyoung的博客
08-12 379
力扣股票买卖问题
leetcode股票问题dp汇总
qq_35299223的博客
04-14 203
股票问题dp 1状态设定 定义dp[i][k][j]为第i天（从0~n-1），当前最多买入k次，j为0或1，表示当前是否持有股票。 2 递推关系 dp[i][k][0] = max(dp[i-1][k][0], dp[i-1][k][1] + prices[i]) max( 选择 rest , 选择 sell ) 解释：今天我没有持...
轻轻松松搞懂股票问题
qq_29257201的博客
12-06 227
【动态规划系列】轻轻松松搞懂股票问题
动态规划之股票问题详解
weixin_43287459的博客
08-19 780
而将状态具体展开：0-表示第一次持有股票，1-表示第一次不持有股票，2-表示第二次持有股票，3-表示第二次不持有股票，4-表示第三次持有股票，5-表示第三次不持有股票，..... ，通过分析可以看出为偶数时表示持有股票的状态，为奇数时表示不持有股票的状态。而本题是最多买卖两次，可以买卖一次，也可以买卖两次，因此需要记录每次持有股票时是第几次持有股票，不持有股票时是第几次不持有股票，故需要四个状态来记录：0-第一次持有股票，1-第一次不持有股票，2-第二次持有股票，3-第二次不持有股票。其余代码和分析相同。
打卡第四天 P1081 [NOIP2012 提高组] 开车旅行
hjxxlsx的博客
10-06 441
【代码】打卡第四天 P1081 [NOIP2012 提高组] 开车旅行。
代码随想录算法训练营Day28 | 39. 组合总和、40.组合总和Ⅱ、131.分割回文串
jiabao0520的博客
10-08 1289
训练营第28天：39. 组合总和、40.组合总和Ⅱ、131.分割回文串
c语言练习题2(字符串和函数的使用)
最新发布
m0_74859128的博客
10-10 200
回文函数用于判断一个给定的字符串是否为回文。输入是一个字符数组（字符串），输出是一个布尔值，表示该字符串是否为回文。编写一个 C 语言程序，计算两个整数在二进制表示中有多少位不同。2. 比较这两个整数在二进制表示中的每一位（共32位）是否不同。1. 提示用户输入两个整数。3. 统计不同的位的数量。4. 输出不同的位数。
ICPC-day2(圆方树)
m0_74315028的博客
10-08 275
每次询问两点x, y，求是否存在一个n的排列，使得第一个元素为x，最后一个元素为y，且排列的任意一个前缀、任意一个后缀都连通。可以用圆方树缩点将其变成一颗树，再判断这颗树是否是一条链，x,y是否在这条链的两侧。其实就是求这两个点是否存在两个不相同的路径，同时两者路径的交集是n。
C语言动态内存管理(26)
tan180°的博客
10-06 1138
如果未来要想学好数据结构，那么你对指针、结构体还有本篇的动态内存的理解掌握能力是要很高的所以跟我一起开始本篇的学习吧！在C99中，结构体最后一个成员为未知大小的数组，这个被称为柔性数组的成员，帮助用户根据要求自己给大小，更加轻松地处理可变长度的数据结构int i;// 有些编译器可能会编译失败，可以化成nums[]}type_a;几个定语修饰词要搞明白，最后一个成员、未知大小、数组应该不算太难，算修炼内功，但很重要，部分代码必须自己去实践！
【算法】---归并排序（递归非递归实现）
何春秋的博客
10-03 1191
归并排序 in Java
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

时是石头

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值