LeetCode第188题_买卖股票的最佳时机IV

LeetCode 第188题：买卖股票的最佳时机 IV

题目描述

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

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

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

难度

困难

题目链接

点击在LeetCode中查看题目

示例

示例 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 。

提示

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

解题思路

方法一：动态规划

这是一个经典的股票交易问题，可以使用动态规划解决。我们定义状态 dp[i][j][0/1] 表示第 i 天，已经进行了 j 次交易，当前持有/不持有股票的最大利润。

关键点：

1. 状态定义：dp[i][j][0] 表示第 i 天，已经完成 j 笔交易，手上没有股票的最大利润；dp[i][j][1] 表示第 i 天，已经完成 j 笔交易，手上持有股票的最大利润
2. 状态转移方程：
   • dp[i][j][0] = max(dp[i-1][j][0], dp[i-1][j][1] + prices[i])：第 i 天不持有股票，可能是昨天也不持有，或者昨天持有但今天卖出
   • dp[i][j][1] = max(dp[i-1][j][1], dp[i-1][j-1][0] - prices[i])：第 i 天持有股票，可能是昨天也持有，或者昨天不持有但今天买入（这样就完成了 j 笔交易中的一次买入）
3. 特殊情况处理：当 k 大于数组长度的一半时，问题退化为允许无限次交易

时间复杂度：O(nk)，其中 n 是天数，k 是最大交易次数
空间复杂度：O(nk)，可以优化到 O(k)

方法二：优化的动态规划（状态压缩）

我们可以对方法一进行空间优化，因为每一天的状态只与前一天的状态有关，所以可以使用滚动数组优化空间。

关键点：

1. 使用两个长度为 k+1 的数组记录当前不持有股票和持有股票的最大利润
2. 从前往后进行状态转移，更新每一天的状态

时间复杂度：O(n*k)，其中 n 是天数，k 是最大交易次数
空间复杂度：O(k)

代码实现

C# 实现

public class Solution {
    public int MaxProfit(int k, int[] prices) {
        if (prices == null || prices.Length <= 1 || k <= 0) {
            return 0;
        }
        
        int n = prices.Length;
        
        // 如果k很大，问题退化为允许无限次交易
        if (k >= n / 2) {
            return MaxProfitInfinite(prices);
        }
        
        // dp[i][0] 表示第i次交易后不持有股票的最大利润
        // dp[i][1] 表示第i次交易后持有股票的最大利润
        int[,] dp = new int[k + 1, 2];
        
        // 初始化：第0天完成i次交易的情况
        for (int i = 0; i <= k; i++) {
            dp[i, 0] = 0;         // 不持有股票，利润为0
            dp[i, 1] = -prices[0]; // 持有股票，利润为-prices[0]
        }
        
        // 动态规划过程
        for (int i = 1; i < n; i++) {
            for (int j = 1; j <= k; j++) {
                // 第i天不持有股票：可能是前一天也不持有，或者前一天持有但今天卖出
                dp[j, 0] = Math.Max(dp[j, 0], dp[j, 1] + prices[i]);
                
                // 第i天持有股票：可能是前一天也持有，或者前一天不持有（完成了j-1次交易）但今天买入
                dp[j, 1] = Math.Max(dp[j, 1], dp[j - 1, 0] - prices[i]);
            }
        }
        
        return dp[k, 0];
    }
    
    // 处理无限次交易的情况（贪心算法）
    private int MaxProfitInfinite(int[] prices) {
        int maxProfit = 0;
        for (int i = 1; i < prices.Length; i++) {
            if (prices[i] > prices[i - 1]) {
                maxProfit += prices[i] - prices[i - 1];
            }
        }
        return maxProfit;
    }
}

Python 实现

class Solution:
    def maxProfit(self, k: int, prices: List[int]) -> int:
        if not prices or len(prices) <= 1 or k <= 0:
            return 0
        
        n = len(prices)
        
        # 如果k很大，问题退化为允许无限次交易
        if k >= n // 2:
            return self.maxProfitInfinite(prices)
        
        # dp[i][0] 表示第i次交易后不持有股票的最大利润
        # dp[i][1] 表示第i次交易后持有股票的最大利润
        dp = [[0, -prices[0]] for _ in range(k + 1)]
        dp[0][1] = float('-inf')  # 不允许在没有交易的情况下持有股票
        
        # 动态规划过程
        for i in range(1, n):
            for j in range(1, k + 1):
                # 第i天不持有股票
                dp[j][0] = max(dp[j][0], dp[j][1] + prices[i])
                
                # 第i天持有股票
                dp[j][1] = max(dp[j][1], dp[j-1][0] - prices[i])
        
        return dp[k][0]
    
    # 处理无限次交易的情况（贪心算法）
    def maxProfitInfinite(self, prices: List[int]) -> int:
        max_profit = 0
        for i in range(1, len(prices)):
            if prices[i] > prices[i-1]:
                max_profit += prices[i] - prices[i-1]
        return max_profit

C++ 实现

class Solution {
public:
    int maxProfit(int k, vector<int>& prices) {
        if (prices.empty() || prices.size() <= 1 || k <= 0) {
            return 0;
        }
        
        int n = prices.size();
        
        // 如果k很大，问题退化为允许无限次交易
        if (k >= n / 2) {
            return maxProfitInfinite(prices);
        }
        
        // dp[i][0] 表示第i次交易后不持有股票的最大利润
        // dp[i][1] 表示第i次交易后持有股票的最大利润
        vector<vector<int>> dp(k + 1, vector<int>(2, 0));
        
        // 初始化：第0天完成i次交易的情况
        for (int i = 0; i <= k; i++) {
            dp[i][0] = 0;            // 不持有股票，利润为0
            dp[i][1] = -prices[0];   // 持有股票，利润为-prices[0]
        }
        
        // 动态规划过程
        for (int i = 1; i < n; i++) {
            for (int j = 1; j <= k; j++) {
                // 第i天不持有股票
                dp[j][0] = max(dp[j][0], dp[j][1] + prices[i]);
                
                // 第i天持有股票
                dp[j][1] = max(dp[j][1], dp[j-1][0] - prices[i]);
            }
        }
        
        return dp[k][0];
    }
    
private:
    // 处理无限次交易的情况（贪心算法）
    int maxProfitInfinite(const vector<int>& prices) {
        int maxProfit = 0;
        for (int i = 1; i < prices.size(); i++) {
            if (prices[i] > prices[i - 1]) {
                maxProfit += prices[i] - prices[i - 1];
            }
        }
        return maxProfit;
    }
};

性能分析

各语言实现的性能对比：

实现语言	执行用时	内存消耗	特点
C#	92 ms	38.6 MB	优化的动态规划实现，空间复杂度为O(k)
Python	112 ms	18.7 MB	使用二维列表实现动态规划
C++	8 ms	10.6 MB	性能最优，使用vector实现动态规划

补充说明

代码亮点

1. 特殊情况快速处理：当 k 大于数组长度的一半时，使用贪心算法处理无限次交易
2. 状态压缩优化：使用滚动数组优化空间复杂度从 O(n*k) 到 O(k)
3. 动态规划状态转移方程设计清晰，易于理解

动态规划的思考过程

股票交易问题的动态规划思路是经典的状态定义和转移模式：

1. 首先定义状态，包括天数、交易次数和是否持有股票
2. 然后考虑状态转移：每天都有"买入"、"卖出"或"不操作"三种可能
3. 最后考虑边界情况：初始状态和特殊情况处理

在本题中，由于交易次数有限，我们需要在动态规划状态中加入"已完成的交易次数"这一维度。当 k 较大时，问题可以简化为贪心算法。

常见错误

1. 没有处理 k 大于数组长度一半的特殊情况，导致内存超限
2. 状态定义不清晰，混淆了"已完成交易次数"和"正在进行的交易"
3. 初始化状态错误，尤其是对于持有股票状态的初始化
4. 没有考虑空数组或 k=0 的边界情况

相关题目

• 121. 买卖股票的最佳时机
• 122. 买卖股票的最佳时机 II
• 123. 买卖股票的最佳时机 III
• 309. 最佳买卖股票时机含冷冻期
• 714. 买卖股票的最佳时机含手续费