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

给你一个整数数组 prices 和一个整数 k ，其中 prices[i] 是某支给定的股票在第 i 天的价格。

设计一个算法来计算你所能获取的最大利润。你最多可以完成 k 笔交易。也就是说，你最多可以买 k 次，卖 k 次。

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

示例 1：

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

示例 2：

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

提示：

• 1 <= k <= 100
• 1 <= prices.length <= 1000
• 0 <= prices[i] <= 1000

最多交易k次

动态规划-数组递推

buy[i][j] 表示第 i+1 天最多进行 j 次交易且持有股票的最大利润，sell[i][j] 表示第 i+1 天最多进行 j 次交易且不持有股票的最大利润，初始化两个矩阵的第一行buy[0][0]和sell[0][0]和buy[0][i]=sell[0][i]（=Integer.MIN_VALUE / 2），正序遍历价格数组和交易次数，计算矩阵中剩余的元素。123题是最多2笔交易，本题是k笔。正序遍历，这个解法更好。

class Solution {
    public int maxProfit(int k, int[] prices) {
        if (prices.length == 0) {
            return 0; // 如果没有价格信息，利润为0
        }

        int n = prices.length;
        k = Math.min(k, n / 2); // 最大交易次数不能超过 n/2

        // 定义二维数组 buy 和 sell
        // buy[i][j] 表示第 i 天最多进行 j 次交易且持有股票的最大利润，i代表索引。
        // sell[i][j] 表示第 i 天最多进行 j 次交易且不持有股票的最大利润。
        // 注意我们有0次交易这种情况，所以要定义k+1列。
        int[][] buy = new int[n][k + 1];
        int[][] sell = new int[n][k + 1];

        // 初始化第0天的 base case
        buy[0][0] = -prices[0];
        sell[0][0] = 0;
        for (int j = 1; j <= k; ++j) {
            buy[0][j] = sell[0][j] = Integer.MIN_VALUE / 2; // 设置为较小的值，避免影响后续计算。重点。
        }

        // 遍历价格数组，从第1天开始
        for (int i = 1; i < n; ++i) {
            // 第i+1天，不进行任何交易时的持有和不持有股票的最大利润
            // 倒序遍历可以省略buy[i][0]的计算。
            // sell[i][0]=Math.max(sell[i][0], buy[i-1][-1]+prices[i])=sell[i][0]，
            // 注意不是Math.max(sell[i][0], prices[i])，因为buy[i-1][-1]不存在导致buy[i-1][-1]+prices[i]不存在。
            buy[i][0] = Math.max(buy[i - 1][0], sell[i - 1][0] - prices[i]);
            for (int j = 1; j <= k; ++j) {
                // 第i+1天，进行j次交易且持有股票的最大利润。注意只买入不算交易次数。
                buy[i][j] = Math.max(buy[i - 1][j], sell[i - 1][j] - prices[i]);
                // 第i+1天，进行j次交易且不持有股票的最大利润
                sell[i][j] = Math.max(sell[i - 1][j], buy[i - 1][j - 1] + prices[i]);
            }
        }

        // 返回第n天，最多进行k次交易且不持有股票的最大利润
        return Arrays.stream(sell[n - 1]).max().getAsInt();
    }
}

滚动更新

class Solution {
    public int maxProfit(int k, int[] prices) {
        if (prices.length == 0) {
            return 0; // 如果没有价格信息，利润为0
        }

        int n = prices.length;
        k = Math.min(k, n / 2); // 最大交易次数不能超过 n/2

        // 定义一维数组 buy 和 sell
        // buy[j] 表示第 i 天最多进行 j 次交易且持有股票的最大利润
        // sell[j] 表示第 i 天最多进行 j 次交易且不持有股票的最大利润
        int[] buy = new int[k + 1];
        int[] sell = new int[k + 1];

        // 初始化第0天的 base case
        buy[0] = -prices[0];
        sell[0] = 0;
        for (int i = 1; i <= k; ++i) {
            buy[i] = sell[i] = Integer.MIN_VALUE / 2; // 设置为较小的值，避免影响后续计算
        }

        // 遍历价格数组，从第1天开始
        for (int i = 1; i < n; ++i) {
            // 第i天，不进行任何交易时的持有和不持有股票的最大利润
            buy[0] = Math.max(buy[0], sell[0] - prices[i]);
            for (int j = 1; j <= k; ++j) {
                // 第i天，进行j次交易且持有股票的最大利润
                buy[j] = Math.max(buy[j], sell[j] - prices[i]);
                // 第i天，进行j次交易且不持有股票的最大利润
                sell[j] = Math.max(sell[j], buy[j - 1] + prices[i]);
            }
        }

        // 返回最多进行k次交易且不持有股票的最大利润
        return Arrays.stream(sell).max().getAsInt();
    }
}

• 时间复杂度： $O(n \min (n, k))$ ，其中 $n$ 是数组 prices 的大小，即我们使用二重循环进行动态规划需要的时间。
• 空间复杂度： $O(n \min (n, k))$ 或 $O(\min (n, k))$ ，取决于我们使用二维数组还是一维数组进行动态规划。