2020-09-20

study-leetcode-188 买卖股票的最佳时机4

1.题目描述
给定一个数组，它的第 i 个元素是一支给定的股票在第 i 天的价格。设计一个算法来计算你所能获取的最大利润。你最多可以完成 k 笔交易。注意: 你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

2.设计思想
三维DP动态规划，第一维表示天，第二维表示交易了几次，第三维表示是否持有股票。初始化三维数组，填充第1天操作j次的没买或买了的情况的初始值，没买就是0，第一天就买入即-prices[0]。这里定义卖出操作时交易次数加1。然后是状态转移方程，i, j都大于0：
（1）第i天交易次数0不持有股票的情况只能来自第i-1天交易次数0不持有股票；
（2）第i天交易j次不持有股票的状态可以来自第i-1天交易j次不持有股票或者第i-1天交易j-1次持有股票(即今天卖出股票，然后交易次数+1)；
（3）第i天交易j次持有股票的状态可以来自第i-1天交易j次持有股票或者第i-1天交易j次不持有股票(即今天买入股票，因为是买入操作所以交易次数不变)。
最后对于这题LeetCode的测试样例里有超大k值的情况，可以用贪心解决或者直接替换k值为数组长度的一半。

3.相关代码

python

class Solution:
    def maxProfit(self, k: int, prices: List[int]) -> int:
        if not prices or not k:
            return 0
        n = len(prices)
        if k > n//2:
            return self.greedy(prices)
        dp = [[[0]*2 for i in range(k+1)] for j in range(n)]
        # dp[i][k][0]表示第i天已交易k次时不持有股票 
        # dp[i][k][1]表示第i天已交易k次时持有股票
        # 设定在卖出时加1次交易次数
        for i in range(k+1):
            dp[0][i][0] = 0
            dp[0][i][1] = - prices[0]
        for i in range(1, n):
            for j in range(k+1):
                if not j:
                    dp[i][j][0] = dp[i-1][j][0]
                else:
                    dp[i][j][0] = max(dp[i-1][j][0],dp[i-1][j-1][1]+prices[i])
                dp[i][j][1] = max(dp[i-1][j][1], dp[i-1][j][0] - prices[i])
        #所有交易次数最后一天不持有股票」的集合的最大值即为问题的解
        temp = []
        for m in range(k+1):
            temp.append(dp[n-1][m][0])
        result = max(temp)
        return result
    
    # 当k值过大时，直接计算买卖所有股票可以获得的最大利益
    def greedy(self, prices):
        result = 0
        for i in range(1, len(prices)):
            if prices[i] > prices[i-1]:
                result += prices[i] - prices[i-1]
        return result

C++

class Solution {
public:
    int greedy(vector<int>& prices) {
        int result = 0;
        for(int i = 1; i < prices.size(); ++i){
            if(prices[i] > prices[i - 1]){
                result += prices[i] - prices[i - 1];
            }
        }
        return result;
    }

    int maxProfit(int k, vector<int>& prices) {
        if(!k || !prices.size()){
            return 0;
        }
        int n = prices.size();
        if(k > n / 2){
            return greedy(prices);
        }
        int dp[n][k+1][2];
        for(int i = 0; i < k + 1; ++i){
            dp[0][i][0] = 0;
            dp[0][i][1] = - prices[0];
        }
        for(int i = 1; i < n; ++i){
            for(int j = 0; j < k + 1; ++j){
                if(!j){
                    dp[i][j][0] = dp[i-1][j][0];
                }
                else{
                    dp[i][j][0]=max(dp[i-1][j][0],dp[i-1][j-1][1]+prices[i]);
                }
                dp[i][j][1] = max(dp[i-1][j][1], dp[i-1][j][0] - prices[i]);
            }
        }
        int result = 0;
        for(int m = 0; m < k + 1; ++m){
            result = max(dp[n-1][m][0],result);
        }
        return result;
    }
};

4.算法效率
时间复杂度：O（ n ）
空间复杂度：O（ n^3 ）