LeetCode 买卖股票的最佳时机系列 121. 122. 123. 188. 309. 714

121

Easy

题目描述：

给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。

你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。

返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。

思路：

当天买入当天卖出不会影响最终结果。所以只需要遍历一次，对于第i天，计算在这天卖出能获取的最大利润（遍历的过程中维护第i天之前的最小价格即可），然后取个最大值即可。

class Solution {
    public int maxProfit(int[] prices) {
        int min = prices[0], ans = 0;
        for (int i = 0; i < prices.length; i++) {
            min = Math.min(min, prices[i]);
            ans = Math.max(ans, prices[i] - min);
        }
        return ans;
    }
}

122

medium

在121的基础上，不限制交易次数。但是任何时候最多只能持有一股。即必须先完成一笔交易，才能进行下一笔。

思路：

由于不限制交易次数，我们可以采用贪心的策略，只要出现某一天的价格大于前一天，就进行一次交易。即把全部的递增区间给累加起来，就能得到最大的利润。

贪心：

class Solution {
    public int maxProfit(int[] prices) {
        int ans = 0;
        for (int i = 1; i < prices.length; i++) {
            if (prices[i] > prices[i - 1]) {
                ans += prices[i] - prices[i - 1];
            }
        }
        return ans;
    }
}

动态规划：

也可以考虑用动规来做，这也是比较通用的做法。

每天结束时，只会有2种状态：持股 or 不持股。

所以这样来设计状态表示：

dp[i][0]表示，在第i天结束时，并且不持股，累计获得的最大利润。

dp[i][1]表示，在第i天结束时，并且持股，累计获得的最大利润。

那么最终答案就是dp[n - 1][0]，即最后一天结束时，不持股，累计获得的最大利润。

状态转移：

根据前一天的状态直接转移即可

当天不持股，可能是昨天就不持股了，或者昨天持股但今天卖出了。

dp[i][0] = max {dp[i - 1][0], dp[i - 1][1] + prices[i]}

当天持股，可能是昨天就持股了，或者昨天没持股但今天买入了。

dp[i][1] = max {dp[i - 1][1], dp[i - 1][0] - prices[i]}

边界：

dp[0][0] = 0 第一天啥也不做

dp[0][1] = -prices[0] 第一天买入

class Solution {
    public int maxProfit(int[] prices) {
        int n = prices.length;
        int[][] dp = new int[n][2];
        dp[0][1] = -prices[0];
        for (int i = 1; i < n; i++) {
            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 - 1][0] - prices[i]);
        }
        return dp[n - 1][0];
    }
}

滚动数组优化：由于每一天有2个状态，且分别只依赖前一天的2个状态，所以可以优化为常数级空间复杂度。

class Solution {
    public int maxProfit(int[] prices) {
        int n = prices.length;

        int hold = -prices[0]; // 当天持股
        int notHold = 0;  // 当天不持股
        
        for (int i = 1; i < n; i++) {
            int oldHold = hold, oldNotHold = notHold;
            hold = Math.max(oldHold, oldNotHold - prices[i]);
            notHold = Math.max(oldNotHold, oldHold + prices[i]);
        }
        return notHold;
    }
}

123

hard

在121的基础上，限制最多交易次数为2。

我们在状态表示中多加一个维度，把交易次数也包含进去即可。

dp[i][0][0]：第i天结束时，未持股状态，累计交易次数为0，获得的累计最大利润

dp[i][0][1]：第i天结束时，未持股状态，累计交易次数为1，获得的累计最大利润

dp[i][0][2]：第i天结束时，未持股状态，累计交易次数为2，获得的累计最大利润

dp[i][1][0]：第i天结束时，持股状态，累计交易次数为0，获得的累计最大利润

dp[i][1][1]：第i天结束时，持股状态，累计交易次数为1，获得的累计最大利润

dp[i][1][2]：第i天结束时，持股状态，累计交易次数为2，获得的累计最大利润

最终的答案是：max {dp[n - 1][0][0-2]} 最后一天不持股，进行了0次，1次，2次交易中的最大值

状态边界：

dp[0][0][0] = 0 第一天什么也不做

dp[0][0][1] = -inf 不可能的状态

dp[0][0][2] = -inf 不可能的状态

dp[0][1][0] = -prices[0] 第一天买入

dp[0][1][1] = -inf 不可能的状态

dp[0][1][2] = -inf 不可能的状态

class Solution {

    // 注意 负无穷 不要设为 int 的最小值, 因为int最小值-1就会反转为int最大值
    int INF = Integer.MIN_VALUE / 2;

    public int maxProfit(int[] prices) {
        int n = prices.length;

        // 进行了多少次买卖
        int [][][] dp = new int[n][2][3];

        dp[0][0][0] = 0;
        dp[0][0][1] = INF;
        dp[0][0][2] = INF;

        dp[0][1][0] = -prices[0];
        dp[0][1][1] = INF;
        dp[0][1][2] = INF;

        for (int i = 1; i < n; i++) {
			// 在当天卖出股票时, 交易次数+1
            // dp[i][0][0] = 0; // 无用状态, 不列出
            dp[i][0][1] = Math.max(dp[i - 1][0][1], dp[i - 1][1][0] + prices[i]);
            dp[i][0][2] = Math.max(dp[i - 1][0][2], dp[i - 1][1][1] + prices[i]);

            dp[i][1][0] = Math.max(dp[i - 1][1][0], -prices[i]);
            dp[i][1][1] = Math.max(dp[i - 1][1][1], dp[i - 1][0][1] - prices[i]);
            // dp[i][1][2] = INF // 无用状态, 不列出
        }
        return Math.max(Math.max(dp[n - 1][0][1], dp[n - 1][0][2]), 0);
    }
}

188

hard

通用模型来了。这道题的交易次数通过参数k进行控制。

思路与123这道题类似，不赘述。

class Solution {
    
    int INF = Integer.MIN_VALUE / 2;
    
    public int maxProfit(int k, int[] prices) {
        if (prices.length <= 1) return 0;
        int n = prices.length;
        int[][][] dp = new int[n][2][k + 1];
        
        // dp[0][0][0] = 0
        // dp[0][0][1-k] = INF
        // dp[0][1][0] = -prices[0]
        // dp[0][1][1-k] = INF
        
        // init
        dp[0][1][0] = -prices[0];
        for (int i = 1; i <= k; i++) {
            dp[0][0][i] = dp[0][1][i] = INF;
        }

        for (int i = 1; i < n; i++) {
            // dp[i][0][0-k]
            // dp[i][1][0-k]
            dp[i][0][0] = 0;
            dp[i][1][0] = Math.max(dp[i - 1][1][0], dp[i - 1][0][0] - prices[i]);
            for (int j = 1; j <= k; j++) {
                dp[i][0][j] = Math.max(dp[i - 1][0][j], dp[i - 1][1][j - 1] + prices[i]);
                dp[i][1][j] = Math.max(dp[i - 1][1][j], dp[i - 1][0][j] - prices[i]);
            }
        }

        int ans = 0;
        for (int i = 1; i <= k; i++) {
            ans = Math.max(ans, dp[n - 1][0][i]);
        }
        return ans;
    }
}

309

medium

在122这道题的基础上，增加了冷冻期。不限制交易次数，但当天若卖出股票，则第二天无法买入（需要隔一天）。相当于技能有了CD。

思路也比较简单，对于当天是否卖出股票这一信息，我们在状态表示中额外增加一个维度。

dp[i][0][0]：第i天结束时，未持股，且当天没有卖出股票。

dp[i][0][1]：第i天结束时，未持股，且当天卖出股票。

dp[i][1][0]：第i天结束时，持股，且当天没有卖出股票。

dp[i][1][1]：第i天结束时，持股，且当天卖出股票。（不可能的状态）

class Solution {
    
    int INF = Integer.MIN_VALUE / 2;

    public int maxProfit(int[] prices) {
        int n = prices.length;
        // 最后一个参数是, 当天是否卖出, 若卖出则第二天无法购买
        int[][][] dp = new int[n][2][2];
        
        dp[0][0][0] = 0;
        dp[0][0][1] = INF;
        dp[0][1][0] = -prices[0];
        dp[0][1][1] = INF;

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

        return Math.max(dp[n - 1][0][0], dp[n - 1][0][1]);
    }
}

714

medium

在122的基础上，增加了手续费。不限交易次数，但每笔交易都需要额外产生一笔手续费。

思路也很简单，在状态转移方程中加上手续费的计算即可。

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

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

总结：股票类问题，可以有一个通用的思路。考虑每天结束时，持股状态，并且把限制条件添加到状态表示中进行维护即可。

参考这篇文章