309. 最佳买卖股票时机含冷冻期

309. 最佳买卖股票时机含冷冻期

题目链接:309. 最佳买卖股票时机含冷冻期(中等)

给定一个整数数组prices，其中第 prices[i] 表示第 *i* 天的股票价格 。

设计一个算法计算出最大利润。在满足以下约束条件下，你可以尽可能地完成更多的交易（多次买卖一支股票）:

• 卖出股票后，你无法在第二天买入股票 (即冷冻期为 1 天)。

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

示例 1:

输入: prices = [1,2,3,0,2]
输出: 3 
解释: 对应的交易状态为: [买入, 卖出, 冷冻期, 买入, 卖出]

示例 2:

输入: prices = [1]
输出: 0

提示：

• 1 <= prices.length <= 5000

• 0 <= prices[i] <= 1000

解题思路

本题与122. 买卖股票的最佳时机II 的不同在于多了一个冷冻期。并且通过题目可以发现，什么时候买入股票受到冷冻期的直接限制，而什么时候卖出股票并没有受到冷冻期的直接限制。

本题还是用动态规划来解答，具体分析在代码注释中。

C++

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        if (prices.size() == 1) return 0;
        // 1. dp数组的含义
        // dp[i][0]表示在第i天持有股票(可能是第i天买入的，也可能是之前买入的)得到的最大金额
        // dp[i][0]表示在第i天不持有股票(可能是第i天卖出的，也可能是之前卖出的)得到的最大金额
        vector<vector<int>> dp(prices.size(), vector<int>(2, 0));
        // 3. dp数组的初始化，根据递推公式，需要初始化4个参数
        // 在第0天想要持有股票只能买入，所得的最大金额就是买第1天股票花费的钱，为负数
        dp[0][0] = -prices[0];
        // 在第0天不持有股票，那最大金额就是0
        dp[0][1] = 0;
        // 在第1天持有股票有两种情况，取最大值
        dp[1][0] = max(dp[0][0], -prices[1]);
        // 在第1天不持有股票有两种情况，取最大值
        dp[1][1] = max(dp[0][1], dp[0][0] + prices[1]);
        // 4.遍历顺序：从前向后
        for (int i = 2; i < prices.size(); i++) {
            // 2.递推公式
            // 第i天持有股票有两种情况
            // 情况1：第i天之前就持有股票，第i天不做任何操作dp[i][0] = dp[i - 1][0]
            // 情况2：在第i天买入股票，那两天前应该不是持有状态
            // 情况2可以这样理解：
            // 21. 如果第i-1天是冷冻期，那第i-1天也是不持有股票的状态，此时的dp[i - 1][1] = dp[i - 2][1]
            // 22. 如果到第i-1天已经度过冷冻期了，由于已经在情况1中把第i-1天就持有股票的情况排除了，所以此处的第i-1天还是不持有股票的，
            // 并且第i-1天也不能通过卖出股票的方式来达到不持有股票，否则就与情况2的前提(第i天买入股票)相违背，因此dp[i - 1][1] = dp[i - 2][1]
            // 结论：那么第i天买入股票后的 dp[i][0] = dp[i - 1][1] - prices[i] = dp[i - 2][1] - prices[i]
            dp[i][0] = max(dp[i - 1][0], dp[i - 2][1] - prices[i]);
            // 在第i天不持有股票有两种情况(注意：什么时候买入股票会受到冷冻期的限制，但什么时候卖出股票并不会受到限制)
            // 情况1：第i-1天就不持有，第i天不做任何操作
            // 情况2：在第i-1天持有股票的情况下卖出赚钱
            dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] + prices[i]);
        }
        return dp[prices.size() - 1][1];
    }
};

JavaScript

/**
 * @param {number[]} prices
 * @return {number}
 */
var maxProfit = function(prices) {
    if (prices.length === 1) return 0;
    const dp = Array(prices.length).fill().map(item => Array(2).fill(0));
    dp[0][0] = -prices[0];
    dp[0][1] = 0;
    dp[1][0] = Math.max(dp[0][0], -prices[1]);
    dp[1][1] = Math.max(dp[0][1], dp[0][0] + prices[1]);
    for (let i = 2; i < prices.length; i++) {
        dp[i][0] = Math.max(dp[i - 1][0], dp[i - 2][1] - prices[i]);
        dp[i][1] = Math.max(dp[i - 1][1], dp[i - 1][0] + prices[i]);
    }
    return dp[prices.length - 1][1];
};

• 时间复杂度：O(n)

• 空间复杂度：O(n)