股票问题

最新推荐文章于 2021-01-11 14:23:21 发布

段某不吃饭

最新推荐文章于 2021-01-11 14:23:21 发布

阅读量105

点赞数

文章标签：动态规划

本文链接：https://blog.csdn.net/long20190318/article/details/110479805

版权

121. 买卖股票的最佳时机

给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。
如果你最多只允许完成一笔交易（即买入和卖出一支股票一次），设计一个算法来计算你所能获取的最大利润。
注意：你不能在买入股票前卖出股票。
示例 1:
输入: [7,1,5,3,6,4]
输出: 5
解释: 在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。
注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格；同时，你不能在买入前卖出股票。

解：
利⽤「状态」进⾏穷举：这个问题的「状态」有三个，i
第⼀个是天数，i
第⼆个是允许交易的最⼤次数，k
第三个是当前的持有状态( 1 表⽰持有,0 表⽰没有持有).
每天都有三种「选择」：买⼊、卖出、⽆操作.

三维数组：dp[i][k][0]:第i天，交易k次，没有股票
⽐如说 dp[3][2][1]的含义就是：今天是第三天，我现在⼿上持有着股票，⾄今最多进⾏ 2 次交易。
再⽐如 dp[2][3][0] 的含义：今天是第⼆天，我现在⼿上没有持有股票，⾄今最多进⾏ 3 次交易。

要的答案是dp[pricesSize-1][k][0].

(一)两个状态转移方程：
//第i天的利润只与昨天(i-1)有关

dp[i][k][0]=max(dp[i-1][k][0],dp[i-1][k][1]+prices[i]);
解释：今天没有持有股票，有两种可能：
1:是昨天就没有持有，然后今天选择无操作，所以今天还是没有持有；
2:是昨天持有股票，但是今天卖了，所以今天没有持有股票。
dp[i][k][1]=max(dp[i-1][k][1], dp[i-1][k-1][0]-prices[i])
解释：今天持有着股票，有两种可能：
1:昨天就持有着股票，然后今天选择无操作，所以今天还持有着股票；
2:昨天就没有持有，但今天选择买入，所以今天就持有股票了。
因为买入股票了，所以k-1;

(二)初始值：
dp[-1][k][0] = 0
解释：因为 i 是从 0 开始的，所以 i = -1 意味着还没有开始，这时候的利润是 0。

dp[-1][k][1] = -infinity
解释：还没开始的时候，是不可能持有股票的，⽤负⽆穷表⽰这种不可能。

dp[i][0][0] = 0
解释：因为 k 是从 1 开始的，所以 k = 0 意味着根本不允许交易，这时候利润当然是 0。

dp[i][0][1] = -infinity
解释：不允许交易的情况下，是不可能持有股票的，⽤负⽆穷表⽰这种不可能。

好，对于这道题，k=1;所以可以对状态转移方程进行降维优化：
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], dp[i-1][0][0] - prices[i])
= max(dp[i-1][1][1], -prices[i])
因为dp[i][0][0]=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对数组无影响，所以去除k:

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

int maxProfit(int* prices, int pricesSize){
if(pricesSize==0)return 0;
int **dp=(int **)malloc(sizeof(int*)*pricesSize);
for(int i=0;i<pricesSize;i++)
    dp[i]=(int *)calloc(2,sizeof(int));//二维数组定义

for(int i=0;i<pricesSize;i++)
{
    if(i-1==-1)//i=0初始化
    {
        dp[i][0]=0;
        dp[i][1]=-prices[i];
        continue;
    }
//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]);
dp[i][0]=max(dp[i-1][0],dp[i-1][1]+prices[i]);
dp[i][1]=max(dp[i-1][1],-prices[i]);//-prices[i],,
                                    //no:dp[i-1][0]-prices[i]
}
return dp[pricesSize-1][0];
}

122. 买卖股票的最佳时机 II

给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。

设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。
（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是无穷大，所以k-1=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][0]-prices[i]);

同样的，可以消去k,得到：

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 maxProfit(int* prices, int pricesSize){

if(pricesSize==0)
return 0;
// dp[i][k][0/1]
/*
dp[i][k][0]=dp[i-1][k][0],dp[i-1][k][1]+prices[i];
dp[i][k][1]=dp[i-1][k][0],dp[i-1][k-1][0]+prices[i];
//k-1=k,,,
dp[i][k][1]=dp[i-1][k][0],dp[i-1][k][0]+prices[i];
//消去k
dp[i][0]=dp[i-1][0],dp[i-1][1]+prices[i];
dp[i][1]=dp[i-1][1],dp[i-1][0]-prices[i];
*/
int **dp=(int**)malloc(sizeof(int *)*pricesSize);
for(int i=0;i<pricesSize;i++)
    dp[i]=(int *)malloc(sizeof(int)*2);

dp[0][0]=0;//i=0时，初始值
dp[0][1]=-prices[0];

for(int i=1;i<pricesSize;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]);
}
return dp[pricesSize-1][0];
}

188. 买卖股票的最佳时机 IV 困难

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

设计一个算法来计算你所能获取的最大利润。你最多可以完成 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时，第二个公式后面k-1为0，则那一项dp[i-1][0][0]=0 ! //交易次数不为0
即：for循环：mk=1,mk<=k;

if(mk==1)
{
dp[i][mk][0]=max(dp[i-1][mk][0],dp[i-1][mk][1]+prices[i]);
dp[i][mk][1]=max(dp[i-1][mk][1],-prices[i]);
//mk=1时，后面dp[i-1][0][0]为0,所以是-prices[i]
continue;
}

int maxProfit(int k, int* prices, int pricesSize){
if(pricesSize==0)return 0;
if(k==0)return 0;
int ***dp=(int ***)malloc(sizeof(int **)*pricesSize);
for(int i=0;i<pricesSize;i++)
{
    dp[i]=(int **)malloc(sizeof(int *)*(k+1));//第二维度大小为k+1
    for(int j=0;j<=k;j++)
    {
        dp[i][j]=(int *)malloc(sizeof(int)*2);
    }
}
for(int i=0;i<=k;i++)//第0天的时候的初始化
{
    dp[0][i][0]=0;
    dp[0][i][1]=-prices[0];
}
for(int i=1;i<pricesSize;i++)
{
    for(int mk=1;mk<=k;mk++)
    {
        if(mk==1)
        {
dp[i][mk][0]=max(dp[i-1][mk][0],dp[i-1][mk][1]+prices[i]);
dp[i][mk][1]=max(dp[i-1][mk][1],-prices[i]);
//mk=1时，后面为0-prices[i]
continue;
		}
dp[i][mk][0]=max(dp[i-1][mk][0],dp[i-1][mk][1]+prices[i]);
dp[i][mk][1]=max(dp[i-1][mk][1],dp[i-1][mk-1][0]-prices[i]);
    }
}

return dp[pricesSize-1][k][0];
}

123. 买卖股票的最佳时机 III 困难

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

即交易次数k<=2;

还是同样的状态转移方程：

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

第0天时，初始化：(第二维大小为2+1)
for(int i=0;i<3;i++)
{
dp[0][i][0]=0;
dp[0][i][1]=-prices[0];
}

//当k=1时，初始化:
if(k=1)
{
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],-prices[i]);
//k==1时：dp[i-1][1-1][0]=0
continue;
}

int maxProfit(int* prices, int pricesSize){
if(pricesSize==0)return 0;
int ***dp=(int***)malloc(sizeof(int**)*pricesSize);
    for(int i=0;i<pricesSize;i++)
    {
        dp[i]=(int **)malloc(sizeof(int*)*3);//大小为2+1
        for(int j=0;j<=2;j++)
        {
            dp[i][j]=(int *)malloc(sizeof(int)*2);
        }
    }
for(int i=0;i<3;i++) //第0天时，初始化
    {
        dp[0][i][0]=0;
        dp[0][i][1]=-prices[0];
    }
    
for(int i=1;i<pricesSize;i++)
{
    for(int k=1;k<=2;k++)
    {
	if(k==1)
{
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],-prices[i]);
//k==1时初始化，dp[i-1][k-1][0]=0
continue;
}
	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]);
    }
}

return dp[pricesSize-1][2][0];//结果
}

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

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

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

你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
卖出股票后，你无法在第二天买入股票 (即冷冻期为 1 天)。
解：
k是无穷大
i天;k次;0/1没有/持有

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-2][k-1][0]-prices[i]);
//k-1可看作k !所以写成：
dp[i][k][1]=max(dp[i-1][k][1],dp[i-2][k][0]-prices[i]);
还要注意这里买股票时的利润有i-2天决定，冷冻期1天

然后发现第二维k不影响，所以去除k，得到：

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

int maxProfit(int* prices, int pricesSize){
if(pricesSize==0)return 0;

int **dp=(int **)malloc(sizeof(int*)*pricesSize);
for(int i=0;i<pricesSize;i++)
    dp[i]=(int *)malloc(sizeof(int)*2);
//因为有冷冻期的存在，所以做1或2天时的初始化，注意i-2要大于0
if(pricesSize>0)//至少有一天
{
dp[0][0]=0;
dp[0][1]=-prices[0];
}
if(pricesSize>1)//至少有两天
{
dp[1][0]=max(dp[0][0],dp[0][1]+prices[1]);
dp[1][1]=max(-prices[0],-prices[1]);//dp[0][1],dp[-1][0]-prices[1]
}
//第3天和后面的i-2都大于0
for(int i=2;i<pricesSize;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-2][0]-prices[i]); //i-2>=0
}
return dp[pricesSize-1][0];
}

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

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

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

返回获得利润的最大值。

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

还是同样的状态转移方程：
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为无穷大:k-1=k。
然后在购买股票的时候多减去fee的手续费。

优化得到：

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[0][0]=0;
dp[0][1]=-prices[0]-fee;

int maxProfit(int* prices, int pricesSize, int fee){
if(pricesSize==0)return 0;

int **dp=(int**)malloc(sizeof(int*)*pricesSize);
    for(int i=0;i<pricesSize;i++)
    {
        dp[i]=(int *)malloc(sizeof(int)*2);
    }
dp[0][0]=0;
dp[0][1]=-prices[0]-fee;

for(int i=1;i<pricesSize;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);
    //购买股票时多减去fee
}
return dp[pricesSize-1][0];