leetcode309——最佳买卖股票时机含冷冻期——java实现

最新推荐文章于 2021-11-26 16:20:49 发布

烛承幻

最新推荐文章于 2021-11-26 16:20:49 发布

阅读量844

点赞数

CC 4.0 BY-SA版权

分类专栏： leecode 文章标签：手撕代码

本文链接：https://blog.youkuaiyun.com/qq_41645636/article/details/99609208

leecode 专栏收录该内容

117 篇文章

订阅专栏

本文深入解析了使用动态规划解决股票交易问题的通用方法，通过对比一维和二维数组实现，阐述了状态转移方程及代码实现细节，帮助读者理解如何最大化股票买卖利润。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目要求：
在这里插入图片描述

分析：
这里给出一大神对于股票题目的通用解法：传送门：一个方法团灭 6 道股票问题
看完之后，不能说是醍醐灌顶吧，反正是写得非常非常清晰。
下图中，上半部分的是通用的式子，下半部分是这道题目的状态转移方程。
在这里插入图片描述
我又要感叹了，真是大神辈出，膜拜膜拜~~~
好了，直接上代码吧。

具体代码如下：

class Solution {
    public int maxProfit(int[] prices) {
        int n = prices.length;
        int dp_i_0 = 0, dp_i_1 = Integer.MIN_VALUE;
        int dp_pre_0 = 0; // 代表 dp[i-2][0]
        int[][] dp = new int[n][n];
        for (int i = 0; i < n; i++) {
            int temp = dp_i_0;
            dp_i_0 = Math.max(dp_i_0, dp_i_1 + prices[i]);
            dp_i_1 = Math.max(dp_i_1, dp_pre_0 - prices[i]);
            dp_pre_0 = temp;
        }
        return dp_i_0;
    }
}

其实最初的时候，我是不理解这个变量的，因为如果用二维数组，它的表达式明明是这样的：

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

那么为什么用变量代替之后，表达式就变成下面形式了呢？

dp_i_0 = Math.max(dp_i_0, dp_i_1 + prices[i]);
dp_i_1 = Math.max(dp_i_1, dp_pre_0 - prices[i]);

仔细分析之后，可以了解这个变量仅仅只是代表一个状态而已，比如dp_i_0存储的只是你在第i天不持有股票时的状态。那么当你要求第i天不持有股票的状态的时候，Math.max(dp_i_0, dp_i_1 + prices[i])中的dp_i_0肯定是之前存储的不持有股票的状态，即第i - 1天不持有股票的状态。dp_i_1同理。那么当求了Math.max(dp_i_0, dp_i_1 + prices[i])之后，dp_i_0的值就被替换掉了，即被替换成了第i天不持有股票状态的值。

下面附上我用二维数组的dp来做的代码：

class Solution {
    public int maxProfit(int[] prices) {
        if(prices == null || prices.length == 0)
            return 0;
            
        int n = prices.length;
        int[][]dp = new int[n][2];
        
        for(int i = 0; i < n; i ++) {
            if(i - 1 == -1) {
                dp[i][0] = 0;
                dp[i][1] = -prices[i];
                continue;
            }
            
            if(i - 1 == 0) {
                dp[i][0] = Math.max(dp[i - 1][0], dp[i - 1][1] + prices[i]);
                dp[i][1] = Math.max(dp[i - 1][1], -prices[i]);
                continue;
            }
            
            dp[i][0] = Math.max(dp[i - 1][0], dp[i - 1][1] + prices[i]);
            dp[i][1] = Math.max(dp[i - 1][1], dp[i - 2][0] - prices[i]);
        }
        return dp[n - 1][0];
    }
}

可以看到，这里就是在for循环中多了两个判断，而且不能忘记prices为空的判断，否则会报错。
这种做法更通俗易懂，而且性能更高。缺点是：空间复杂度变高了。
得失并存嘛~