动态规划DP（七）股票交易

最新推荐文章于 2024-10-27 05:38:01 发布

绿风天空

最新推荐文章于 2024-10-27 05:38:01 发布

阅读量136

点赞数

分类专栏： leetcode(c++) 文章标签：动态规划算法 c++ 面试

本文链接：https://blog.csdn.net/jmqxnxg/article/details/131626732

版权

leetcode(c++) 专栏收录该内容

55 篇文章 0 订阅

订阅专栏

1.股票交易

在股票买卖的最佳时机问题中，给定一个数组，数组中的每个元素代表某一天的股票价格。你可以进行多次买入和卖出，但是必须在再次购买前卖出之前的股票。目标是找到最大的利润。

动态规划可以用于解决股票交易类的问题，其中最常见的问题是股票买卖的最佳时机问题（Best Time to Buy and Sell Stock）。

2.题目

1）

力扣https://leetcode.cn/problems/best-time-to-buy-and-sell-stock/找到当前位置之前的元素中的最小值，与当前位置的元素相减，遍历一维数组，找到最大差值。

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int minp = prices[0];
        int n = prices.size();
        int res = 0;
        for(int i=1;i<n;i++){
            res = max(res, prices[i]-minp);
            minp = min(minp, prices[i]);
        }
        return res;
    }
};

力扣https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-iii/这道题的难点在于最多购买股票两次，如果一直顺序考虑股票数组，就会变得很复杂，需要记录的值很多。

所有可以顺序加逆序考虑：

顺序：找到当前位置之前的最小值，当前位置元素与之计算差值，保留最大的差值。

逆序：找到当前位置之后的最大值，最大值与当前位置元素计算差值，保留最大的差值。

这样对于每个位置，都知道了这个位置之前一次购买卖出的最大利润，和这个位置以及这个位置之后一次购买卖出的最大利润。

把这个两个值相加，得到的就是每个位置最多购买两次彩票时的最大值。

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int n = prices.size();

        vector<int> dp(n,0);
        int minp = prices[0];
        for(int i=1;i<n;i++){
            dp[i] = max(dp[i-1], prices[i]-minp);
            minp = min(minp, prices[i]);
        }

        vector<int> dp2(n,0);
        int maxp = prices[n-1];
        for(int i=n-2;i>=0;i--){
            dp2[i] = max(dp2[i+1], maxp-prices[i]);
            maxp = max(maxp, prices[i]);
        }

        int res = 0;
        for(int i=0;i<n;i++){
            res = max(res, dp[i]+dp2[i]);
        }

        return res;
    }
};

力扣https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-iv/题解：

这题需要额外考虑完成k次交易这一因素

所以转移方程为：buy[i][j]代表遍历prices[0...i]完成j笔交易，且此刻持有一只股票的最大收益。

sell[i][j]代表遍历prices[0...i]完成j笔交易，且此刻不持有股票的最大收益。

所以buy[i][j] = max(buy[i-1][j], sell[i-1][j]-prices[i])

取只考虑i-1只股票且完成j笔交易手上有股票的收益，或者只考虑i-1只股票且完成j笔交易购买当前这只股票收益

sell[i][j] = max(sell[i-1][j], buy[i-1][j-1]+prices[i])

取只考虑i-1只股票且完成j笔交易手上没有股票的收益，或者只考虑i-1只股票且此时卖出股票收益达到j笔交易的收益

这题好绕啊，建议自己码一下，会清晰很多。

代码：

class Solution {
public:
    int maxProfit(int k, vector<int>& prices) {
        int n = prices.size();
        vector<vector<int>> buy(n,vector<int>(k+1,INT_MIN/2));
        vector<vector<int>> sell(n,vector<int>(k+1,INT_MIN/2));
        if(2*k>=n) k = n/2;

        buy[0][0] = -prices[0];
        sell[0][0] = 0;
        
        for(int i=1;i<n;i++){
            sell[i][0] = 0;
            buy[i][0] = max(buy[i-1][0], sell[i-1][0]-prices[i]);
            for(int j=1;j<=k;j++){
                buy[i][j] = max(buy[i-1][j], sell[i-1][j]-prices[i]);
                sell[i][j] = max(sell[i-1][j], buy[i-1][j-1]+prices[i]);

            }
        }
        int res =  *(max_element(sell[n-1].begin(), sell[n-1].end()));
        return res>=0?res:0;
    }
};

因为是二维数组，且每次更新只用到[i-1]的值，所以肯定是可以压缩的。

压缩后，因为buy在sell前更新，所以 sell[i][j] = max(sell[i-1][j], buy[i-1][j-1]+prices[i])

就变成了 sell[i][j] = max(sell[i-1][j], buy[i][j-1]+prices[i])

又因为buy[i][j-1] = max(buy[i-1][j-1], sell[i-1][j-1]-prices[i]);

代入 sell[i][j]，得到 sell[i][j] = max(sell[i-1][j], buy[i-1][j-1]+prices[i]，sell[i-1][j-1] -prices[i]+prices[i])

比原本的 sell[i][j]多出了这一项：sell[i-1][j-1] -prices[i]+prices[i]

这一项表示在前i-1只股票中完成了j-1次交易，然后第j次交易是卖入第i只股票再在当天卖出。

所以也是sell[i-1][j]的一种特殊情况，所以多出的这一项不会比sell[i-1][j]大，也就不会影响最终的结果了。

所以是可以压缩数组的。

class Solution {
public:
    int maxProfit(int k, vector<int>& prices) {
        int n = prices.size();
        vector<int> buy(k+1,INT_MIN/2);
        vector<int> sell(k+1,INT_MIN/2);
        if(2*k>=n) k = n/2;

        buy[0] = -prices[0];
        sell[0] = 0;
        
        for(int i=1;i<n;i++){
            buy[0] = max(buy[0], sell[0]-prices[i]);
            for(int j=1;j<=k;j++){
                buy[j] = max(buy[j], sell[j]-prices[i]);
                sell[j] = max(sell[j], buy[j-1]+prices[i]);

            }
        }
        int res =  *(max_element(sell.begin(), sell.end()));
        return res>=0?res:0;
    }
};

速度明显变快了：

4）

力扣https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-with-cooldown/

股票交易的题，最后代码都不复杂，但是设计转移方程的过程真的很绕。

这题多了一个冷冻期，也就是除了买和卖之外，又多了一个冷冻的状态。

dp[i]表示第i天结束之后的最大收益：

dp[i][0]表示第i天结束之后，手上持有一只股票
dp[i][1]表示第i天结束之后，手上不持有股票，且处于冷冻期
dp[i][1]表示第i天结束之后，手上不持有股票，不处于冷冻期

接下来分类讨论：

dp[i][0]表示第i天结束之后，手上持有一只股票

所以手上这只股票可以是今天买的，也可以是前一天就买了的

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

dp[i][1]表示第i天结束之后，手上不持有股票，且处于冷冻期

这表示第i天卖了股票，所以第i天结束之后，才会处于冷冻期

dp[i]][0] = dp[i-1][0]+prices[i]

dp[i][1]表示第i天结束之后，手上不持有股票，不处于冷冻期

第i天结束之后不处于冷冻期，那么前一天结束之后可以是冷冻期，也可以不是冷冻期

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

代码：

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

        for(int i=1;i<n;i++){
                dp[i][0] = max(dp[i-1][0], dp[i-1][2]-prices[i]);
                dp[i][1] = dp[i-1][0]+prices[i];
                dp[i][2] = max(dp[i-1][2], dp[i-1][1]);
           
        }
        return max(dp[n-1][1], dp[n-1][2]);
    }
};

转移方程中dp[i]只与dp[i-1]相关，所以可以压缩转移方程。简单地用六个变量来代替二维数组。

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int n = prices.size();
        vector<vector<int>> dp(n, vector<int>(3,INT_MIN/2));
        int f0,f1,f2,f3,f4,f5;
        f0 = -prices[0];
        f1 = 0;
        f2 = 0;

        for(int i=1;i<n;i++){
            
                f3 = max(f0, f2-prices[i]);
                f4 = f0+prices[i];
                f5 = max(f2, f1);
                f0 = f3;
                f1 = f4;
                f2 = f5;
           
        }
        return max(f1,f2);
    }
};

速度快了很多：