买卖股票的最佳时机 6种问题解答_股票最优交易问题-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_45608849/article/details/106802972

这是一个动态规划的题目，所以我们首先要找的是状态方程
我们每天买卖股票都有3种选择：买、卖、没有操作
我们这个问题有3个参数：天数、允许交易的次数、当天是否持有股票
我们以 0 作为未持有股票，1 作为持有股票
比如 a[3][1][0]：就表示今天是第3天，我手上没有股票，至今最多交易1次
a[5][2][1]：就表示今天是第5天，我现在手上持有股票，至今最多交易两次
下面我们来看一下状态方程：

1.

比如我们今天手里有股票，那这个股票有两个来源：1.我们前一天已经有股票了 2.我们前一天没有股票，今天买了一张
那我们今天的状态就是在这两种里面选一种获利最大的
a[i][k][1] = Math.max(a[i-1][k][1],a[i-1][k-1][0]-今天的股票价格)
a[i-1][k][1]表示前一天已经有股票
a[i-1][k-1][0]-今天的股票价格 表示前一天没股票，今天买了一张

2.

另外一种情况就是今天手里没有股票，有两种情况：1.我们前一天就没有股票 2. 我们前一天有股票，今天把股票卖了
a[i][k][0] = Math.max(a[i-1][k][0],a[i-1][k][1]+今天的股票价格)
a[i-1][k][0] 表示前一天没有股票
a[i-1][k][1]+今天的股票价格 表示前一天有股票，今天把股票卖了

现在我们就把状态方法找出来了，下来我们一起分析这6道题：

(1). k == 1

只有一次交易的机会，直接套用状态方程：

a[i][1][0] = Math.max(a[i-1][1][0],a[i-1][1][1]+price[i]);
a[i][1][1] = Math.max(a[i-1][1][1],a[i-1][0][0]-price[i]);
		   = Math.max(a[i-1][1][1],-price[i])
		   
因为当 k == 0时,相当于还没有交易,所以 a[i][0][0] = 0;

i = 0,意思是第1天
当 i == 0时,第1天手里没有股票，所以,a[0][0] = 0;
           第1天手里有股票，就相当于欠钱买的，所以a[0][1] = -prices[0];
                      
现在所有的 k == 1;所以k不影响方程,所以可以去掉
那就得到方程为：
a[i][0] = Math.max(a[i-1][0],a[i-1][1]+price[i]);
a[i][1] = Math.max(a[i-1][1],-price[i]);

代码就是：

int n = prices.length;
int[][] a = new int[n][2];
for(int i = 0;i < n;i++){
	if( i == 0){
		a[i][0] = 0;
		a[i][1] = -prices[i];
		continue;
	}
	a[i][0] = Math.max(a[i-1][0],a[i-1][1]+prices[i]);
	a[i][1] = Math.max(a[i-1][1],-prices[i]); 
}
return a[n-1][0];

观察上面状态方程可以得到，新的状态只和相邻的状态相关，所以我们只需要一个变量来储存相邻的状态就可以了，这样空间复杂度就是O(1)
优化后的代码：

int n = prices.length;
int a_0 = 0;
int a_1 = Integer.MIN_VALUE;
for(int i = 0;i < n;i++){
	a_0  = Math.max(a_0 ,a_1+prices[i]);
	a_1  = Math.max(a_1 ,-prices[i]); 
}
return a_0;

(2). k == +无穷

如果k是正无穷，那k和k-1就是一样的
那状态方程可以写为：

a[i][k][0] = Math.max(a[i-1][k][0],a[i-1][k][1]+price[i]);
a[i][k][1] = Math.max(a[i-1][k][1],a[i-1][k-1][0]-price[i]);
		   = Math.max(a[i-1][k][1],a[i-1][k][0]-price[i])
发现都有k,那就可以把k省略掉
a[i][0] = Math.max(a[i-1][0],a[i-1][1]+price[i]);
a[i][1] = Math.max(a[i-1][1],a[i-1][0]-price[i]);

代码为：

int n = prices.length;
int a_0 = 0;
int a_1 = Integer.MIN_VALUE;
for(int i = 0;i < n;i++){
	// 由于a_1式中需要使用前一天的a_0
	// 所以就需要先把a_0保存下来再进行计算今天的
	int tmp = a_0;
	a_0  = Math.max(a_0 ,a_1+prices[i]);
	a_1  = Math.max(a_1 ,tmp-prices[i]); 
}
return a_0;

(3). k == 2

先列出状态方程：

a[i][2][0] = Math.max(a[i-1][2][0],a[i-1][2][1]+price[i]);
a[i][2][1] = Math.max(a[i-1][2][1],a[i-1][1][0]-price[i])
		   = Math.max(a[i-1][2][1],a[i-1][1][0]-price[i]);
由于k == 2,原始不能进行简化，那我们就需要一个三维数组
还要对k进行穷举,所以一共穷举 n(天数)*k(交易次数)*2(是否持有股票) 种状态

代码为：

int n = prices.length;
int m_k = 2;
// 第一个 n 是总天数
// 第二个 m_k 是第0次交易、第一次交易、第二次交易 所以是3个长度
// 第三个 2 是当天手里有股票和当天手里没股票两种情况
int[][][] a = new int[n][m_k+1][2];
for(int i = 0;i < n;i++){
	for(int k = m_k;k > 0;k--){
		// i == 0,
		// 就相当于第一天
		// 没股票就是0
		// 有股票就是欠钱买的
		if(i == 0){
			a[i][k][0] = 0;
			a[i][k][1] = -prices[i];
			continue;
		}
		a[i][k][0] = Math.max(a[i-1][k][0],a[i-1][k][1]+price[i]);
		a[i][k][1] = Math.max(a[i-1][k][1],a[i-1][k-1][0]-price[i]);
	}
}
return a[n-1][m_k][0];

(4). k == 任意整数

这个题和第3个题思路是一样，不过这个题需要考虑的是如果传入的k值过大，因为一次交易是买入和卖出组成的，如果k > n/2 ,那就说明没有约束作用的，就和第2题是一样的了，所以我们结合题目2和题目3得出此题答案

public int maxProfit(int k,int[] prices){
	int n = prices.length;
	if(k > n/2){
		greedy(prices);
	}
	int m_k = 2;
	// 第一个 n 是总天数
	// 第二个 m_k 是第0次交易、第一次交易、第二次交易 所以是3个长度
	// 第三个 2 是当天手里有股票和当天手里没股票两种情况
	int[][][] a = new int[n][m_k+1][2];
	for(int i = 0;i < n;i++){
		for(int k = m_k;k > 0;k--){
			// i == 0,
			// 就相当于第一天
			// 没股票就是0
			// 有股票就是欠钱买的
			if(i == 0){
				a[i][k][0] = 0;
				a[i][k][1] = -prices[i];
				continue;
			}
			a[i][k][0] = Math.max(a[i-1][k][0],a[i-1][k][1]+price[i]);
			a[i][k][1] = Math.max(a[i-1][k][1],a[i-1][k-1][0]-price[i]);
		}
	}
	return a[n-1][m_k][0];
}
public int greedy(int[] prices){
	int n = prices.length;
	int a_0 = 0;
	int a_1 = Integer.MIN_VALUE;
	for(int i = 0;i < n;i++){
		// 由于a_1式中需要使用前一天的a_0
		// 所以就需要先把a_0保存下来再进行计算今天的
		int tmp = a_0;
		a_0  = Math.max(a_0 ,a_1+prices[i]);
		a_1  = Math.max(a_1 ,tmp-prices[i]); 
	}
	return a_0;
}

(5). 含手续费

每笔交易都要付手续费，那我们就每次交易减去手续费就好啦
每次在买入股票的时候就减掉手续费
把k省略掉，那状态方程就为：

a[i][0] = Math.max(a[i-1][0],a[i-1][1]+price[i]);
a[i][1] = Math.max(a[i-1][1],a[i-1][0]-price[i]-fee);

int n = prices.length;
int a_0 = 0;
int a_1 = Integer.MIN_VALUE;
for(int i = 0;i < n;i++){
	// 由于a_1式中需要使用前一天的a_0
	// 所以就需要先把a_0保存下来再进行计算今天的
	int tmp = a_0;
	a_0  = Math.max(a_0 ,a_1+prices[i]);
	a_1  = Math.max(a_1 ,tmp-prices[i]-fee); 
}
return a_0;

(6). 含冷冻期(隔一天交易)

每卖出一次，就隔一天才能买入，那状态方程买股票往后推一天就ok
状态方程为：

a[i][0] = Math.max(a[i-1][0],a[i-1][1]+price[i]);
a[i][1] = Math.max(a[i-1][1],a[i-2][0]-price[i]);

代码为：

int n = prices.length;
int a_0 = 0;
int a_1 = Integer.MIN_VALUE;
int a_pre = 0;   // 代表a[i-2][0]
for(int i = 0;i < n;i++){
	// 由于需要保存前两天的结果
	// 先保存前一天的
	// 然后今天的计算完，在把前一天的赋值给a_pre
	// 最后下一天在使用的时候，就是前两天的值
	int tmp = a_0;
	a_0  = Math.max(a_0 ,a_1+prices[i]);
	a_1  = Math.max(a_1 ,a_pre-prices[i]); 
	a_pre = tmp;
}
return a_0;