DAY51:动态规划(十五)买卖股票最佳时机Ⅲ+买卖股票最佳时期Ⅳ

123.买卖股票最佳时机Ⅲ(注意初始化)

  • 本题需要注意DP数组初始化的问题,dp[0]实际上表示的是第一天的情况i的含义是下标i而不是天数i
  • 直接记住这种情况下dp[0]代表的是第1天也可以叫第0天,但是第0天是有对应的prices[0]数据的

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

设计一个算法来计算你所能获取的最大利润。你最多可以完成 两笔 交易。

**注意:**你不能同时参与多笔交易(你必须在再次购买前出售掉之前的股票)。

示例 1:

输入:prices = [3,3,5,0,0,3,1,4]
输出:6
解释:在第 4 天(股票价格 = 0)的时候买入,在第 6 天(股票价格 = 3)的时候卖出,这笔交易所能获得利润 = 3-0 = 3 。
     随后,在第 7 天(股票价格 = 1)的时候买入,在第 8 天 (股票价格 = 4)的时候卖出,这笔交易所能获得利润 = 4-1 = 3

示例 2:

输入:prices = [1,2,3,4,5]
输出:4
解释:在第 1 天(股票价格 = 1)的时候买入,在第 5 天 (股票价格 = 5)的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。   
     注意你不能在第 1 天和第 2 天接连购买股票,之后再将它们卖出。   
     因为这样属于同时参与了多笔交易,你必须在再次购买前出售掉之前的股票。

示例 3:

输入:prices = [7,6,4,3,1] 
输出:0 
解释:在这个情况下, 没有交易完成, 所以最大利润为 0

示例 4:

输入:prices = [1]
输出:0

提示:

  • 1 <= prices.length <= 10^5
  • 0 <= prices[i] <= 10^5

思路

本题和Ⅰ与Ⅱ的区别是,买卖股票Ⅰ是只能买卖一次,买卖股票Ⅱ是可以买卖任意次。但是本题,最多买卖两次

题目限制最多买卖两次,意味着我们必须进行状态的拆分,才能知道目前是买卖了一次还是买卖了两次,因为单从递推公式,不能得知目前的交易是第几次买卖

DP数组含义

之前的dp数组,每一天的天数i对应的一维数组只有0和1两个下标,也就是说每一天只有0和1两个状态。0是持有股票,1是不持有股票。

但是本题因为限制了次数,所以不止0和1两个状态,1需要分为第一次持有和第二次持有0需要分成第一次卖出和第二次卖出

  • dp[i][0]不操作(实际上不需要这个状态,没操作手头现金一定是0)
  • dp[i][1]第一次持有
  • dp[i][2]第一次不持有(也就是第一次卖出)
  • dp[i][3]第二次持有
  • dp[i][4]第二次卖出

递推公式

dp[i][1]是第一次持有,有两个状态:

  • 之前就持有了,dp[i-1][1]
  • 今天刚刚买入,0-prices[i](第一次持有一定是第一次买入,初始值0-prices[i])
dp[i][1] = max(dp[i-1][1],-prices[i]);

dp[i][2]是第一次不持有也就是第一次卖出:

dp[i][2] = max(dp[i-1][2],dp[i-1][1]+prices[i]);//之前第一次持有状态最大现金+卖出现金

dp[i][3]是第二次持有,也就是第二次买入:

  • 在第一次卖出后,也就是第一次不持有的状态基础上进行转移/累加
dp[i][3] = max(dp[i-1][3],dp[i-1][2]-prices[i]);

dp[i][4]是第二次不持有,也就是第二次卖出:

  • 第二次卖出,一定是在第二次买入状态基础上进行叠加
dp[i][4] = max(dp[i-1][4],dp[i-1][3]+prices[i]);

初始化

防止数组下标越界问题,需要初始化dp[0][1]dp[0][2]一直到dp[0][4],代表的是下标为0天,也就是第1天,各种状态下的最大现金数。

下标0天,实际上从天数上来说,是第1天

//第1天第一次持有
dp[0][1] = -prices[0];
//第1天第一次不持有
dp[0][2] = -prices[0]+prices[0] = 0;
//第1天第二次持有
dp[0][3] = -prices[0];
//第1天第二次不持有
dp[0][4] = -prices[0]+prices[0] = 0;

遍历顺序

本题是在前一天状态基础上进行转移,因此是正序遍历

最开始的写法:初始化全部写成0

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        if(prices.size()==1) return 0;
        //分4种状态
        vector<vector<int>>dp(prices.size(),vector<int>(4,0));
        //初始化全部为0,不用管
        for(int i=1;i<prices.size();i++){
            //0:第一次持有
            dp[i][0] = max(dp[i-1][0],-prices[i]);
            //1:第一次不持有
            dp[i][1] = max(dp[i-1][1],dp[i-1][0]+prices[i]);
            //2:第二次持有
            dp[i][2] = max(dp[i-1][2],dp[i-1][1]-prices[i]);
            //3:第二次不持有
            dp[i][3] = max(dp[i-1][3],dp[i-1][2]+prices[i]);
        }
        //最后一定是不持有的状态取最大值
        return max(dp[prices.size()-1][1],dp[prices.size()-1][3]);
    }
};
debug测试:解答错误,第0天实际上是对应prices[0]和dp[0]

在这里插入图片描述
因为dp[0]在这版代码中被全部初始化为0,但是实际上dp[0]对应的是第0天

这个问题在 198.打家劫舍 中也犯过,下标是0的时候,dp[0]含义是偷窃下标为0的房屋得到的最大金额,下标为0的房屋已经对应了一个value[0],所以dp[0]不应该=0,应该=value[0]!

完整版

  • dp[0]实际上表示的是第一天的情况!
  • 第0天,有对应的prices[0]数据
class Solution {
public:
    int maxProfit(vector<int>& prices) {
        if(prices.size()==1) return 0;
        //分4种状态
        vector<vector<int>>dp(prices.size(),vector<int>(4,0));
        //初始化:要初始化下标i=0,也就是第一天的情况
        dp[0][0] = -prices[0];
        //dp[0][1] = -prices[i]+prices[i] = 0;第0天的状态1一定是0
        dp[0][2] = -prices[0];//第0天第二次持有,一定是当天买当天卖
        for(int i=1;i<prices.size();i++){
            //0:第一次持有
            dp[i][0] = max(dp[i-1][0],-prices[i]);
            //1:第一次不持有
            dp[i][1] = max(dp[i-1][1],dp[i-1][0]+prices[i]);
            //2:第二次持有
            dp[i][2] = max(dp[i-1][2],dp[i-1][1]-prices[i]);
            //3:第二次不持有
            dp[i][3] = max(dp[i-1][3],dp[i-1][2]+prices[i]);
        }
        //最后一定是不持有的状态取最大值
        return max(dp[prices.size()-1][1],dp[prices.size()-1][3]);
    }
};

总结

  • DP数组的初始化问题一定要注意,并不是所有的问题都会直接初始化为0i代表的含义是下标i,而不是天数i下标0的时候,实际上代表的是第一天!i的范围是[0,nums.size()-1]dp[0]实际上代表的是第1天持有股票时手里现金的状态
  • 初始化主要是看dp[0]的时候对应的输入数组是不是有取值(同 198.打家劫舍 系列)
  • 当限制了买卖次数,我们又不能从递推公式看出本次买卖是第几次买卖的时候,就只能把每一次买卖的状态都列出来,新的一次买卖一定是在上一次买卖状态的基础上,进行状态转移

188.买卖股票最佳时机Ⅳ

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

设计一个算法来计算你所能获取的最大利润。你最多可以完成 k 笔交易。也就是说,你最多可以买 k 次,卖 k 次。

**注意:**你不能同时参与多笔交易(你必须在再次购买前出售掉之前的股票)。

示例 1:

输入:k = 2, prices = [2,4,1]
输出:2
解释:在第 1(股票价格 = 2) 的时候买入,在第 2(股票价格 = 4) 的时候卖出,这笔交易所能获得利润 = 4-2 = 2

示例 2:

输入:k = 2, prices = [3,2,6,5,0,3]
输出:7
解释:在第 2(股票价格 = 2) 的时候买入,在第 3(股票价格 = 6) 的时候卖出, 这笔交易所能获得利润 = 6-2 = 4 。
     随后,在第 5(股票价格 = 0) 的时候买入,在第 6(股票价格 = 3) 的时候卖出, 这笔交易所能获得利润 = 3-0 = 3

提示:

  • 0 <= k <= 100
  • 0 <= prices.length <= 1000
  • 0 <= prices[i] <= 1000

思路

Ⅲ是至多买卖两次,Ⅳ是至多买卖K次

上一道题目里,我们直接将第一次持有、第一次不持有、第二次持有、第二次不持有进行了状态的拆分,把所有状态都列了出来。

我们可以发现,如果至多允许2次买卖,那么会有4种状态

  • 第1次持有
  • 第1次不持有
  • 第2次持有
  • 第2次不持有

那么我们可以类推得到,如果允许K次买卖,那么第i天的一维数组的状态数量应该是2k种!对于每一个第K次交易,都是第K次持有或者第K次不持有的情况

因此我们可以基于上一题的情况,将一维状态数组下标定义为1–2K,来对应这2K种状态

在这2K种状态中,每一种状态都承接上一种状态

DP数组含义

dp[i][j]表示下标为i天时,第j种状态下手里最大的现金数值,其中j的取值是1–2k2k是总的状态数

递推公式

dp[i][1]表示第1次持有股票

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

dp[i][2]表示第1次不持有股票

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

dp[i][3]表示第2次持有股票

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

dp[i][4]表示第2次不持有股票

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

观察上面几个递推的例子,我们可以得出,递推应该为:

for(int j=1;j<=2k;j++){
    dp[i][j] = max(dp[i-1][j],dp[i-1][j-1]+prices[i]*(-1)^j);//但是这里^的用法是错误的,cpp的幂不是这么算的
}
CPP中求幂存在的问题

但是,这个递推公式在实际编程中可能会遇到一些问题,主要是因为在 C++ 中,(-1)^j 的结果并不是我们所期望的。在 C++ 中,^按位异或运算符,它的行为和数学中的指数运算不同

如果想要实现 (-1)^j 的效果,可以使用条件运算符(也叫三元运算符)来实现:

//改为三目运算符代替幂的操作
for (int j = 1; j <= 2 * k; j++) {
    dp[i][j] = max(dp[i-1][j], dp[i-1][j-1] + (j%2==0?prices[i]:-prices[i]));
}

初始化

介于递推公式涉及到了dp[i-1],因此i=0的情况需要初始化。但是因为每个i的下标都是1–2k范围,因此这个范围内的所有数字都需要初始化!

下标为0,但是仍然有对应的prices[0],也就是代表的是第一天的情况。

dp[0][1] = -prices[0];
dp[0][2] = prices[0]-prices[0] = 0;
dp[0][3] = -prices[0];
//后面都是循环
dp[0][2k] = 0;

因此,初始化写为:

for(int i=1;i<=2k;i++){
    dp[0][i] = (i%2==0)?0:-prices[0];
}

遍历顺序

后面的数值依靠前面的数值,所以是正序遍历。

最开始的写法

class Solution {
public:
    int maxProfit(int k, vector<int>& prices) {
        if(prices.size()==1) return 0;
        vector<vector<int>>dp(prices.size(),vector<int>(2*k+1,0));
        //初始化
        for(int i=1;i<=2*k;i++){
            dp[0][i]=(i%2==0)?0:-prices[0];
        }
        //递推
        for(int i=1;i<prices.size();i++){
            for(int j=1;j<=2*k;j++){
                dp[i][j]=max(dp[i-1][j],dp[i-1][j-1]+(j%2==0)?prices[i]:-prices[i]);
            }
        }
        return *max_element(dp[prices.size()-1].begin(),dp[prices.size()-1].end());
    }
};
debug测试:

完整版

class Solution {
public:
    int maxProfit(int k, vector<int>& prices) {
        if(prices.size()==1) return 0;
        vector<vector<int>>dp(prices.size(),vector<int>(2*k+1,0));
        //初始化
        for(int i=1;i<=2*k;i++){
            dp[0][i]=(i%2==0)?0:-prices[0];
        }
        //递推
        for(int i=1;i<prices.size();i++){
            for(int j=1;j<=2*k;j++){
                dp[i][j]=max(dp[i-1][j],dp[i-1][j-1]+(j%2==0?prices[i]:-prices[i]));
            }
        }
        return *max_element(dp[prices.size()-1].begin(),dp[prices.size()-1].end());
    }
};
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值