LeetCode #188 买卖股票的最佳时机 IV

https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-iv/

题目描述

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

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

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

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

思路

定义求解问题：

对于每一天，可能的操作有两种：买入、卖出。

但是相比于#123，这道题可以只可以买卖两次而不是无限次，因此需要在次数上做限制。

我们将

• dp[i][j][0]：定义为在第i天，完成了j笔交易情况下，没有股票的最大利润
• dp[i][j][1]：定义为在第i天，完成了j笔交易情况下，持有股票的最大利润

状态转移方程：

合法的状态转移一共有种：

• 00->00: 完成交易数为0，没有持有股票
• 00->01: 完成交易数为0，买入股票
• 01->10: 完成交易数加1，出售股票
• 01->01: 完成交易数为0，持有股票
• 10->10: 完成交易数为1，没有持有股票
• 10->11: 完成交易数为1，买入股票
• 11->11: 完成交易数为1，持有股票
• 11->20: 完成交易数加1，出售股票
• 20->20: 完成交易数为2，没有持有股票
• ......
• k0->k0: 完成交易数为k，没有持有股票
• k0->k1: 非法状态，因为交易数已经为k，不能再购买股票

因此：

• dp[i][j][0] = max(dp[i-1][j][0], dp[i-1][j][1] + prices[i]);
• dp[i][j][1] = max(dp[i-1][j][1], dp[i-1][j-1][0] - prices[i]);
• 其中0<i<pricesize, 0<=j<=2

边界条件：

• dp[0][j][0] = 0;
• dp[0][j][1] = -pirce[0]
• 其中0<=j<=k

 实现

在提交时候，第209个测试用例给出可交易次数k为1000000000，显然内存无法分配出这么大的空间。

但是其实交易次数是存在上限的，假如交易的上限次数应该为，因此我们先判断k值是否大于这个值，如果大于这相当于对交易次数没有限制，则转换为题 #122求解。

#define max(a,b) (a>b?a:b)
int maxProfit_inf(int* prices, int pricesSize){
    if(pricesSize==0||pricesSize==1)
        return 0;
    int **dp = (int**)malloc(sizeof(int*)*pricesSize);
    for(int i = 0; i< pricesSize; i++)
        dp[i] = (int*)malloc(sizeof(int)*2);
    for (int i = 0; i < pricesSize; i++) {
        // 边界条件，单独定义买与不买的状态
        if(i - 1 == -1){
            dp[i][0] = 0;
            dp[i][1] = -prices[i];
        }else{
            dp[i][0] = max(dp[i-1][0], dp[i-1][1] + prices[i]);
            dp[i][1] = max(dp[i-1][1], dp[i-1][0] - prices[i]);
        }
    }
    return dp[pricesSize - 1][0];
}
int maxProfit(int k, int* prices, int pricesSize){
    if(pricesSize==0||pricesSize==1)
        return 0;
    // 因为交易次数是具有上限的，如果超过这个上限则题目便转化为无限次交易情况下的最大利润
    if(k>(pricesSize/2)+1)
        return maxProfit_inf(prices, pricesSize);
    int ***dp = (int***)malloc(sizeof(int**)*pricesSize);
    for(int i = 0; i< pricesSize; i++){
        dp[i] = (int**)malloc(sizeof(int*)*(k+1));
        for(int j=0;j < k+1; j++){
            dp[i][j] = (int*)malloc(sizeof(int)*2);
            memset(dp[i][j],0,sizeof(int)*2);
        }
    }
    for (int i = 0; i < pricesSize; i++) {
        for(int j = k; j > 0; j--){
            // 边界条件，单独定义买与不买的状态
            if(i==0){
                dp[i][j][0] = 0;
                dp[i][j][1] = -prices[i];
            }else{
                // 在第i天没持有股票，那么利润就max(本来就没买，把之前的股票卖掉了)
                dp[i][j][0] = max(dp[i-1][j][0], dp[i-1][j][1] + prices[i]);
                // 在第i天持有股票，那么利润等于max(这个股票是之前买，之前没有今天买入)
                dp[i][j][1] = max(dp[i-1][j][1], dp[i-1][j-1][0] - prices[i]);
            }
        }
    }
    return dp[pricesSize - 1][k][0];
}