188. 买卖股票的最佳时机 IV_hard

题目

188. 买卖股票的最佳时机 IV

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

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

 

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

来源：力扣（LeetCode）188. 买卖股票的最佳时机 IV
链接：https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-iv/

---

示例 1:

输入: [2,4,1], k = 2
输出: 2
解释: 在第 1 天 (股票价格 = 2) 的时候买入，在第 2 天 (股票价格 = 4) 的时候卖出，这笔交易所能获得利润 = 4-2 = 2 。

---

示例 2:

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

---

分析

首先，此题还有5道相似的变种：

1. 只进行一次交易，相当于 k = 1；

2. 不限交易次数，相当于 k = +infinity（正无穷）；

3. 第三题是只进行 2 次交易，相当于 k = 2；

4. 剩下两道也是不限次数，但是加了交易「冷冻期」和「手续费」的额外条件，其实就是第二题的变种。

---

每天都有三种「选择」：买入、卖出、无操作，

我们用 buy, sell, rest 表示这三种选择。

然而，并不是每天都可以任意选择这三种选择的，

因为 sell 必须在 buy 之后，buy 必须在 sell 之后。

 

那么 rest 操作也应该分两种状态，

一种是 buy 之后的 rest（持有了股票），

另一种是 sell 之后的 rest（没有持有股票）。

而且别忘了，我们还有交易次数 k 的限制，就是说你 buy 还只能在 k > 0 的前提下操作。

 

这个问题的「状态」有三个：

第一个是天数，

第二个是允许交易的最大次数，

第三个是当前的持有状态（即之前说的 rest 的状态，我们不妨用 1 表示持有，0 表示没有持有）。

然后用一个三维数组就可以装下这几种状态的全部组合：

dp[i][k][0 or 1]
0 <= i <= n-1, 1 <= k <= K
n 为天数，大 K 为最多交易数
此问题共 n × K × 2 种状态，全部穷举出来。

for 0 <= i < n:
    for 1 <= k <= K:
        for s in {0, 1}:
            dp[i][k][s] = max(buy, sell, rest)

比如说 dp[3][2][1] 的含义就是：今天是第三天，我现在手上持有着股票，至今最多进行过 2 次交易。

再比如 dp[2][3][0] 的含义：今天是第二天，我现在手上没有持有股票，至今最多进行过 3 次交易。

 

我们想求的最终答案是 dp[n - 1][K][0]，即：

最后一天，最多允许 K 次交易，最多获得多少利润。

---

dp[i][k][0] = max(dp[i-1][k][0], dp[i-1][k][1] + prices[i])
                   max(   选择 rest  ,             选择 sell      )

今天我没有持有股票，有两种可能：
要么是我昨天就没有持有，然后今天选择 rest，所以我今天还是没有持有；
要么是我昨天持有股票，但是今天我 sell 了，所以我今天没有持有股票了。

---

dp[i][k][1] = max(dp[i-1][k][1], dp[i-1][k-1][0] - prices[i])
                   max(   选择 rest  ,           选择 buy         )

今天我持有着股票，有两种可能：
要么我昨天就持有着股票，然后今天选择 rest，所以我今天还持有着股票；
要么我昨天本没有持有，但今天我选择 buy，所以今天我就持有股票了。

---

注意：这儿，我们约定buy时，交易数+1； sell时，交易数不变；
因为一次buy + 一次sell = 一次交易

---

确定基本情况：

dp[-1][k][0] = 0
解释：因为 i 是从 0 开始的，所以 i = -1 意味着还没有开始，这时候的利润当然是 0 。

dp[-1][k][1] = -infinity
解释：还没开始的时候，是不可能持有股票的，用负无穷表示这种不可能。

dp[i][0][0] = 0
解释：因为 k 是从 1 开始的，所以 k = 0 意味着根本不允许交易，这时候利润当然是 0 。

dp[i][0][1] = -infinity
解释：不允许交易的情况下，是不可能持有股票的，用负无穷表示这种不可能。

---

解题1，当K无限大(不限次数)

k无限大时， k-1 和 k一样

消去k后，代码如下:

class Solution {
    public int maxProfit(int[] priceArr) {
        int dayNum = priceArr.length;
        if (dayNum == 0) {
            return 0;
        }

        int[][] dpArr = new int[dayNum][2];

        for (int i = 0; i < dayNum; i++) {
            if (i == 0) {
                // 第1天啥也不干，当然利润为0
                dpArr[i][0] = 0;
                // 第1天买入股票，出血priceArr[0];
                dpArr[i][1] = -priceArr[i];
                continue;
            }

            dpArr[i][0] = Math.max(dpArr[i-1][0], dpArr[i-1][1] + priceArr[i]);
            dpArr[i][1] = Math.max(dpArr[i-1][1], dpArr[i-1][0] - priceArr[i]);
        }

        return dpArr[dayNum - 1][0];
        
    }
}

---

解题2，当k为任意数时

这儿又要分情况讨论：

如果传入的 k 值非常大时，dpArr 数组太大了。

想想看，交易次数 k 最多有多大呢？

一次交易由买入和卖出构成，至少需要两天。

所以说有效的限制 k 应该不超过 n/2，

如果超过，就没有约束作用了，相当于 k = +infinity。

这种情况是上面解题1中解决过的。

class Solution {
    // k为无限大时
    public int maxProfit_infinite(int[] priceArr) {
        int dayNum = priceArr.length;
        if (dayNum == 0) {
            return 0;
        }

        int[][] dpArr = new int[dayNum][2];

        for (int i = 0; i < dayNum; i++) {
            if (i == 0) {
                dpArr[i][0] = 0;
                dpArr[i][1] = -priceArr[i];
                continue;
            }

            dpArr[i][0] = Math.max(dpArr[i-1][0], dpArr[i-1][1] + priceArr[i]);
            dpArr[i][1] = Math.max(dpArr[i-1][1], dpArr[i-1][0] - priceArr[i]);
        }

        return dpArr[dayNum - 1][0];
    }

    public int maxProfit(int kMax, int[] priceArr) {
        int dayNum = priceArr.length;
        if (dayNum == 0) {
            return 0;
        }

        if (kMax > dayNum / 2) {
            return maxProfit_infinite(priceArr);
        }

        int[][][] dpArr = new int[dayNum][kMax + 1][2];

        for (int i = 0; i < dayNum; i++) {
            for (int k = kMax; k >= 1; k--) {
                if (i == 0) { 
                    // i为-1，表示交易还没有开始，故利润为0
                    // dpArr[-1][k][0] = 0;
                    // i为-1表示交易还没有开始，不可能持有股票，用负无穷表示这种不可能
                    // dpArr[-1][k][1] = Integer.MIN_VALUE;

                    // k是从1开始的， 当k为0代表不允许交易，利润为0
                    dpArr[i][0][0] = 0;
                    // k是从1开始的， 当k为0代表不允许交易，这时是不可能持有股票的，用负无穷表示这种不可能
                    dpArr[i][0][1] = Integer.MIN_VALUE;
                        
                    // 第1天手中没有股票,当然是没交易没收入了
                    dpArr[i][k][0] = 0;
                    // 第1天就持有股票,肯定是买入了啦
                    dpArr[i][k][1] = -priceArr[i];
                    continue;
                }
                dpArr[i][k][0] = Math.max(dpArr[i-1][k][0], dpArr[i-1][k][1] + priceArr[i]);
                dpArr[i][k][1] = Math.max(dpArr[i-1][k][1], dpArr[i-1][k-1][0] - priceArr[i]);
            }
        }
        // 穷举了 dayNum × kMax × 2 个状态，正确。
        return dpArr[dayNum - 1][kMax][0];
    }
}