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

无限次买卖，但卖了有冷冻期~

✍手写分析

（最后由于截图原因，正确return的是[1] [2] [3]）

动规五部曲分析

1. 确定dp数组以及下标的含义

dp[i][j]，第i天状态为j，所剩的最多现金为dp[i][j]。
（注意有了冷冻期后，没有当天卖了后马上进行第二次买卖的操作）
具体可以区分出如下四个状态：

• 状态一：持有股票状态
  • 已经买入，一直持有
  • 当天买入
• 不持有股票状态，这里就有两种卖出股票状态（因为多了冷冻期，因此需要将刚卖出和已经卖出状态分离）
  • 状态二：保持卖出股票的状态（度过冷冻期或卖了之后没买入）
  • 状态三：今天卖出股票
• 状态四：今天为冷冻期状态，但冷冻期状态不可持续，只有一天！

j的状态为：

• 0：状态一 - 持有股票
• 1：状态二 - 保持卖出状态
• 2：状态三 - 当天卖出股票
• 3：状态四 - 当天为冷冻期

（*注意这里的每一个状态，例如状态一，是持有股票股票状态并不是说今天一定就买入股票，而是说保持买入股票的状态即：可能是前几天买入的，之后一直没操作，所以保持买入股票的状态*。）

2. 确定递推公式（难点❗）

一、达到买入股票状态（状态一）即：dp[i][0]，有两个具体操作：

• 操作一：本来就持有，前一天就是持有股票状态（状态一），dp[i][0] = dp[i - 1][0]
• 操作二：今天买入了，有两种情况
  • 买的前一天是冷冻期（状态四）：dp[i - 1][3] - prices[i]
  • 买的前一天是保持卖出股票的状态（状态二），dp[i - 1][1] - prices[i]

因此取以上三个值的最大值，dp[i][0] = max(dp[i - 1][0], dp[i - 1][3] - prices[i], dp[i - 1][1] - prices[i]);
二、达到保持卖出股票状态（状态二）即：dp[i][1]，有两个具体操作：

• 操作一：已经卖出，前一天就是状态二
• 操作二：前一天是冷冻期（状态四）

取最大值，dp[i][1] = max(dp[i - 1][1], dp[i - 1][3]);
三、达到今天就卖出股票状态（状态三），即：dp[i][2] ，只有一个操作：
昨天一定是持有股票状态（状态一），然后在今天卖出
即：dp[i][2] = dp[i - 1][0] + prices[i];
四、达到冷冻期状态（状态四），即：dp[i][3]，只有一个操作：
昨天一定是卖出了股票状态（状态三）
dp[i][3] = dp[i - 1][2];
综上分析，递推代码如下：

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

3. dp数组如何初始化

这里主要讨论一下第0天如何初始化。
如果是持有股票状态（状态一）那么：dp[0][0] = -prices[0]，一定是当天买入股票。
当天买入当天卖出 因此dp[0][1] = 0;
今天卖出了股票（状态三），同上分析，dp[0][2]初始化为0，dp[0][3]也初始为0。

4. 确定遍历顺序

从递归公式上可以看出，dp[i] 依赖于 dp[i-1]，所以是从前向后遍历。

5. 举例推导dp数组

以 [1,2,3,0,2] 为例，dp数组如下：

由于最后结果是取卖出股票的状态, 即状态二，状态三，和状态四的最大值
代码如下：

public int maxProfit(int[] prices) {
    int len = prices.length;
    if (len == 0) return 0;
    int[][] dp = new int[len][4];
    dp[0][0] = -prices[0];

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

    return Math.max(dp[len - 1][1], Math.max(dp[len - 1][2], dp[len - 1][3]));
}

• 时间复杂度：O(n)
• 空间复杂度：O(n)

当然，空间复杂度可以优化，定义一个dp[2][4]大小的数组就可以了，就保存前一天的当前的状态，

714 买卖股票的最佳时机含手续费

无限次买卖，但卖出有手续费~

思路

本题只需要在卖出时减去手续费算max值就行，和 122 买卖股票的最佳时机 Ⅱ 唯一差别在于递推公式部分
这里重申一下dp数组的含义：
dp[i][0] 表示第 i 天不持有股票所得最多现金。 dp[i][1] 表示第 i 天持有股票所省最多现金
如果第 i 天不持有股票即dp[i][0]的情况， 依然可以由两个状态推出来

• 第i-1天就不持有股票，那么就保持现状，所得现金就是昨天不持有股票的所得现金 即：dp[i - 1][0]
• 第i天卖出股票，所得现金就是按照今天股票价格卖出后所得现金，注意这里需要有手续费了即：dp[i - 1][1] + prices[i] - fee

所以：dp[i][1] = max(dp[i - 1][0], dp[i - 1][1] + prices[i] - fee);
在来看看如果第i天持有股票即dp[i][1]， 那么可以由两个状态推出来

• 第i-1天就持有股票，那么就保持现状，所得现金就是昨天持有股票的所得现金 即：dp[i - 1][1]
• 第i天买入股票，所得现金就是昨天不持有股票的所得现金减去 今天的股票价格 即：dp[i - 1][0] - prices[i]

所以：dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] - prices[i]);
以上分析完毕，代码如下：

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

    for (int i = 1; i < len; 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][0] - prices[i], dp[i - 1][1]); // 持有股票
    }

    return dp[len - 1][0];
}

• 时间复杂度：O(n)
• 空间复杂度：O(n)

优化空间：滚动数组

public int maxProfit(int[] prices, int fee) {
    // 优化空间
    int len = prices.length;
    int[][] dp = new int[2][2];
    dp[0][1] = -prices[0];

    for (int i = 1; i < len; i++){
        dp[i % 2][0] = Math.max(dp[(i - 1) % 2][0], dp[(i - 1) % 2][1] + prices[i] - fee);// 不持有股票
        dp[i % 2][1] = Math.max(dp[(i - 1) % 2][0] - prices[i], dp[(i - 1) % 2][1]); // 持有股票
    }

    return dp[(len - 1) % 2][0];
}

• 时间复杂度：O(n)
• 空间复杂度：O(1)

学习资料：

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

714.买卖股票的最佳时机含手续费