Leetcode-123 买卖股票3 dp详细题解

题目详情

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

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

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

示例 1:

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

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

这里得注释一下，本题可以当天卖，当天买

题目解析

首先分析该题，去寻找其子问题，对于第i天的股票，函数f[i]就意味着前i天的利润。
但是第i天如何操作呢？买or卖or等待？
这得取决于前一天是什么情况：

如果前一天是我从没有买过股票，那么此时我可以买
如果前一天我手里有了股票，那么此时我可以选择卖，选择不卖而等待，或者卖了再马上卖一个（虽然这很傻，但实际却是允许，反正没有手续费，爱怎么玩怎么玩）
如果我已经买卖过一只股票，但是当前股价一直跌，我就不买了，等待
如果我已经买卖过两只股票，则此时只能等待。

粗略的分析，就有这么多种情况，当然上面分析的不全，下面来仔细分析一下。
如下图所示：
在这里插入图片描述
注意，这里的阶段2的开启是第一次买，第一次买是包含在阶段2中的；第一次买在阶段3中，后面的同理。

从而，我们可以对于第i天的前i天的利润列出对应的状态转移方程

阶段1： $f [i] [j] = f [] [i - 1] [j]$ ，只能维持前一天的阶段1的利润
阶段2： $f[i][j] = max\{ f[i-1][j-1], f[i-1][j]+p[i]-p[i-1]\}$ ，max中，前一项是前一天的阶段1，代表我今天刚买了股票，从而从阶段1升级到了阶段2；而后一项是前一天的阶段2，今天继续阶段2，即我今天继续持有第一支股票，到今天的利润是前一天的利润+今昨两天的股价差值。
阶段3： $f[i][j] = max\{ f[i-1][j-1]+p[i]-p[j],f[i-1][j]\}$ 。同理，前一项是前一天的阶段2加上股价差，代表，前一天还在持有股票，我今天卖了，那么利润就是前一天持有的利润+今昨的差价；后一项是昨天阶段3的延续，手里没有股票，当然利润延续不变啦。
阶段4： $f[i][j] = max\{ f[i-1][j-2]+p[i]-p[i-1],f[i-1][j-1],f[i-1][j]+p[i]-p[i-1]\}$ 。这里要多一个项。第一项是前一天的阶段2+股价差，代表的是，昨天我还持有第一支股票，然后今天我就卖了，然后今天我又买了第二支，所以直接从第二阶段跨过第三阶段进入第四阶段；第二项是从第三阶段到第四阶段，刚买第二支；第三项是前一天第四阶段的延续，同2，就不细说了，键盘敲累了。
阶段5： $f[i][j] = max\{f[i-1][j-1]+p[i]-p[j],f[i-1][j]\}$ 。此阶段同阶段3，不赘述了。

在状态转移方程列出来后，这题基本就解决了。
这里在敲代码时，很明显，阶段1,3,5是类似的，2,4是类似，它们分别可以放在一块来减少代码量。
所以转移方程可以“优化”成如下形式：

阶段1,3,5： $f[i][j] = max\{f[i-1][j-1]+p[i]-p[j],f[i-1][j]\}$
阶段2,4： $f[i][j] = max\{f[i-1][j-2]+p[i]-p[i-1],f[i-1][j-1],f[i-1][j]+p[i]-p[i-1]\}$

当然，这里要进行判断，判断数组有无越界，总之逻辑稍微有些复杂。
具体见代码实现

代码实现

class Solution {
    
    
    //经典dp问题，需要分析最后一步，或者说当前步的的所需要的参数
    //需要知道前一步是第一次买之前，还是第一次持有股票，还是第二次买之前，还是第二次持有股票，还是第二次卖之后
    //一共5个可变参数，会影响当前股票交易情况
    //然后该题是建立在前面股票问题的基础上来说的，相邻差的累加和就是两端的差值
    public int maxProfit(int[] prices) {
    
    
        if(prices==null || prices.length<2) return 0;

        int n = prices.length;
        int[][] dp = new int[n+1][6];
        dp[0][1] = 0;
        dp[0][2] = Integer.MIN_VALUE;
        dp[0][3] = Integer.MIN_VALUE;
        dp[0][4] = Integer.MIN_VALUE;
        dp[0][5] = Integer.MIN_VALUE;

        for(int i=1; i<n+1; i++){
    
    
            //更新阶段135状态
            for(int j=1; j<=5; j+=2){
    
    
                dp[i][j] = dp[i-1][j];
                if(i>1&&j>1&&dp[i-1][j-1]!=Integer.MIN_VALUE){
    
    
                    dp[i][j] = Math.max(dp[i][j],dp[i-1][j-1]+prices[i-1]-prices[i-2]);
                }
            }
            //更新阶段2,4状态
            for(int j=2; j<=4; j+=2){
    
    
                dp[i][j] = dp[i-1][j-1];
                if(dp[i-1][j]!=Integer.MIN_VALUE){
    
    
                    dp[i][j] = Math.max(dp[i][j],dp[i-1][j]+prices[i-1]-prices[i-2]);
                }
                if(j!=2&&dp[i-1][j-2]!=Integer.MIN_VALUE){
    
    
                        dp[i][j] = Math.max(dp[i][j],dp[i-1][j-2]+prices[i-1]-prices[i-2]);
                    }
            }
        }

        return Math.max(Math.max(dp[n][1],dp[n][3]),dp[n][5]);
    }
}