解题思路

这是股票买卖的通用版本，需要处理k次交易。我们可以使用动态规划来解决：

  1. 创建二维dp数组：
    • 表示第天进行次交易的最大收益
    • 其中范围是，范围是
  2. 对于每一天和交易次数，我们有两种选择：
    • 不进行交易：沿用前一天的收益
    • 进行交易：在之前某一天买入，第i天卖出
  3. 优化空间复杂度：
    • 使用一维数组记录当前的最大收益
    • 用一个变量记录之前的最大可能收益减去买入价格

代码

#include <iostream>
#include <vector>
using namespace std;

int maxProfit(vector<int>& prices, int k) {
    if (prices.empty() || k == 0) return 0;
    int n = prices.size();
    
    // 如果k超过n/2，相当于无限次交易
    if (k >= n/2) {
        int maxProfit = 0;
        for (int i = 1; i < n; i++) {
            if (prices[i] > prices[i-1]) {
                maxProfit += prices[i] - prices[i-1];
            }
        }
        return maxProfit;
    }
    
    vector<int> dp(k+1, 0);
    vector<int> maxDiff(k+1, -prices[0]);
    
    for (int i = 1; i < n; i++) {
        for (int j = k; j >= 1; j--) {
            maxDiff[j] = max(maxDiff[j], dp[j-1] - prices[i-1]);
            dp[j] = max(dp[j], maxDiff[j] + prices[i]);
        }
    }
    
    return dp[k];
}

int main() {
    int n, k;
    cin >> n >> k;
    vector<int> prices(n);
    for(int i = 0; i < n; i++) {
        cin >> prices[i];
    }
    cout << maxProfit(prices, k) << endl;
    return 0;
}

import java.util.Scanner;

public class Main {
    public static int maxProfit(int[] prices, int k) {
        if (prices.length == 0 || k == 0) return 0;
        int n = prices.length;
        
        // 如果k超过n/2，相当于无限次交易
        if (k >= n/2) {
            int maxProfit = 0;
            for (int i = 1; i < n; i++) {
                if (prices[i] > prices[i-1]) {
                    maxProfit += prices[i] - prices[i-1];
                }
            }
            return maxProfit;
        }
        
        int[] dp = new int[k+1];
        int[] maxDiff = new int[k+1];
        for (int j = 0; j <= k; j++) {
            maxDiff[j] = -prices[0];
        }
        
        for (int i = 1; i < n; i++) {
            for (int j = k; j >= 1; j--) {
                maxDiff[j] = Math.max(maxDiff[j], dp[j-1] - prices[i-1]);
                dp[j] = Math.max(dp[j], maxDiff[j] + prices[i]);
            }
        }
        
        return dp[k];
    }
    
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int k = sc.nextInt();
        int[] prices = new int[n];
        for(int i = 0; i < n; i++) {
            prices[i] = sc.nextInt();
        }
        System.out.println(maxProfit(prices, k));
        sc.close();
    }
}

def max_profit(prices, k):
    if not prices or k == 0:
        return 0
    n = len(prices)
    
    # 如果k超过n/2，相当于无限次交易
    if k >= n//2:
        return sum(max(0, prices[i] - prices[i-1]) for i in range(1, n))
    
    dp = [0] * (k+1)
    max_diff = [-prices[0]] * (k+1)
    
    for i in range(1, n):
        for j in range(k, 0, -1):
            max_diff[j] = max(max_diff[j], dp[j-1] - prices[i-1])
            dp[j] = max(dp[j], max_diff[j] + prices[i])
    
    return dp[k]

n, k = map(int, input().split())
prices = list(map(int, input().split()))
print(max_profit(prices, k))

算法及复杂度

  • 算法：动态规划
  • 时间复杂度：，其中 为天数， 为最大交易次数
  • 空间复杂度：，使用了两个长度为 的数组