算法训练day49|动态规划part10

发布时间:2023年12月26日

121. 买卖股票的最佳时机 参考文章:代码随想录

贪心

因为股票就买卖一次,那么贪心的想法很自然就是取最左最小值,取最右最大值,那么得到的差值就是最大利润。

本次重点学习动态规划方法

1. dp数组(dp table)以及下标的含义

dp[i][0] 表示第i天持有股票所得最多现金,一开始现金为负数,所以第一天就持有股票的话,就是为负

dp[i][1] 表示第i天不持有股票所得最多现金

如果按照买入,卖出来分别状态,那什么都不干的状态并不能涵盖

所以应该按照持有,和不持有来区分

持有包含今天买入和之前买入但是这几天一直没变动

不持有包含今天卖出,和之前卖出之后没变动

这两种状态能够涵盖所有情况

2. 递推公式

如果第i天持有股票即dp[i][0], 那么可以由两个状态推出来

  • i-1天就持有股票,那么就保持现状,所得现金就是昨天持有股票的所得现金 即:dp[i - 1][0]
  • i天买入股票,所得现金就是买入今天的股票后所得现金即:-prices[i]

那么dp[i][0]应该选所得现金最大的,所以dp[i][0] = max(dp[i - 1][0], -prices[i]);

如果第i天不持有股票即dp[i][1], 也可以由两个状态推出来

  • 第i-1天就不持有股票,那么就保持现状,所得现金就是昨天不持有股票的所得现金 即:dp[i - 1][1]
  • i天卖出股票,所得现金就是按照今天股票价格卖出后所得现金即:prices[i] + dp[i - 1][0]

同样dp[i][1]取最大的,dp[i][1] = max(dp[i - 1][1], prices[i] + dp[i - 1][0]);

3.初始化

由递推公式 dp[i][0] = max(dp[i - 1][0], -prices[i]); 和 dp[i][1] = max(dp[i - 1][1], prices[i] + dp[i - 1][0]);可以看出

其基础都是要从dp[0][0]和dp[0][1]推导出来,而且在递推过程中只参考前一位,所以有压缩的可能性

那么dp[0][0]表示第0天持有股票,此时的持有股票就一定是买入股票了,因为不可能有前一天推出来,所以dp[0][0] -= prices[0];

dp[0][1]表示第0天不持有股票,不持有股票那么现金就是0,所以dp[0][1] = 0;

4.根据递推公式,dp[i]都是由dp[i - 1]推导出来的,那么一定是从前向后遍历

// 解法1
class Solution {
    public int maxProfit(int[] prices) {
        if (prices == null || prices.length == 0) return 0;
        int length = prices.length;
        // dp[i][0]代表第i天持有股票的最大收益
        // dp[i][1]代表第i天不持有股票的最大收益
        int[][] dp = new int[length][2];
        int result = 0;
        dp[0][0] = -prices[0];
        dp[0][1] = 0;
        for (int i = 1; i < length; i++) {
            dp[i][0] = Math.max(dp[i - 1][0], -prices[i]);
            dp[i][1] = Math.max(dp[i - 1][0] + prices[i], dp[i - 1][1]);
        }
        return dp[length - 1][1];
    }
}

优化:由于递推公式更新时,只需要参考前一位的数值,所以我们可以将空间压缩为2,滚动更新数组

class Solution {
    public int maxProfit(int[] prices) {
        int len = prices.length;
        int dp[][] = new int[2][2];
        
        dp[0][0] = - prices[0];
        dp[0][1] = 0;

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

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

与上题区别:可以买卖多次股票,但是只能持有一个

只有递归公式有区别

如果第i天持有股票即dp[i][0], 那么可以由两个状态推出来

  • i-1天就持有股票,那么就保持现状,所得现金就是昨天持有股票的所得现金 即:dp[i - 1][0]
  • i天买入股票,所得现金就是前一天不持有股票的现金,再减去买入今天的股票后花费的现金即:的 dp[i-1][1]-prices[i]

其他均与上题相同

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        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]); // 注意这里是和121. 买卖股票的最佳时机唯一不同的地方。
            dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] + prices[i]);
        }
        return dp[len - 1][1];
    }
};

由于只需要用到dp[i-1][0],dp[i-1][1]来推导dp[i][0],dp[i][1]

我们可以把dp数组压缩到 2x2的数组,滚动更新

// 版本二
class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int len = prices.size();
        vector<vector<int>> dp(2, vector<int>(2)); // 注意这里只开辟了一个2 * 2大小的二维数组
        dp[0][0] -= prices[0];
        dp[0][1] = 0;
        for (int i = 1; i < len; i++) {
            dp[i % 2][0] = max(dp[(i - 1) % 2][0], dp[(i - 1) % 2][1] - prices[i]);
            dp[i % 2][1] = max(dp[(i - 1) % 2][1], prices[i] + dp[(i - 1) % 2][0]);
        }
        return dp[(len - 1) % 2][1];
    }
};

本题也可以用贪心方法

 // 贪心思路
class Solution {
     public int maxProfit(int[] prices) {
         int result = 0;
         for (int i = 1; i < prices.length; i++) {
             result += Math.max(prices[i] - prices[i - 1], 0);
         }
         return result;
     }
 }

文章来源:https://blog.csdn.net/AdrianLeon/article/details/135212808
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。