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

题目链接

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

题目描述

给你一个整数数组 $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\le k\le 100$
• $1\le prices.length\le 1000$
• $0\le prices[i]\le 1000$

解法一：记忆化搜索

• 我们定义 $dfs(i,j,1)$ 为第 $i$ 天结束的时候最多完成 $j$ 笔交易 且 持有股票 的最大利润；

• 我们定义 $dfs(i,j,0)$ 为第 $i$ 天结束的时候最多完成 $j$ 笔交易 且 不持有股票 的最大利润；

我们固定 在购入一支新股票的时候算作一笔新的交易。

即：

$$dfs(i,j,1)=max\{dfs(i-1,j,1),dfs(i-1,j-1,0)-prices[i])\}$$

$$dfs(i,j,0)=max\{dfs(i-1,j,0),dfs(i-1,j,1)+prices[i])\}$$

对于 $i<0$ 和 $j<0$ 的特殊情况：

$$dfs(i,j,k)=-\infty j<0$$

$$dfs(i,j,k)=\{\begin{array}{ll}0& \text{if }i<0,k=0\\ -\infty & \text{if }i<0,k=1\end{array}$$

时间复杂度： $O(n\times k)$

C++代码：

class Solution {
public:
    int maxProfit(int k, vector<int>& prices) {
        int n = prices.size();
        int f[n][k + 1][2];
        memset(f,-1,sizeof f);

        function<int(int,int,int)> dfs = [&](int i,int j,int hold)->int{
            if(j < 0) return -1e9;
            if(i < 0) return hold ? -1e9 : 0;

            if(f[i][j][hold] != -1) return f[i][j][hold];
            //持有股票
            if(hold){
                f[i][j][hold] = max(dfs(i - 1,j,1) , dfs(i - 1,j - 1,0) - prices[i]);
            }
            else f[i][j][hold] = max(dfs(i - 1,j,0) , dfs(i - 1,j,1) + prices[i]);
            return f[i][j][hold];
        };

        return dfs(n - 1,k,0);
    }
};

解法二：动态规划

我们将状态转移方程 转为 动态规划的状态转移方程：

$$\{\begin{array}{l}f(i,j,1)=max\{f(i-1,j,1),f(i-1,j-1,0)-prices[i])\}\\ f(i,j,0)=max\{f(i-1,j,0),f(i-1,j,1)+prices[i])\}\end{array}$$

对于 $j=-1$ 和 $i=-1$ 这种边界条件我们没有处理。

所以我们只能让其整体向右偏移一位，变为：

$$\{\begin{array}{l}f(i+1,j,1)=max\{f(i,j,1),f(i,j-1,0)-prices[i])\}\\ f(i+1,j,0)=max\{f(i,j,0),f(i,j,1)+prices[i])\}\end{array}$$

此时的边界条件为：

$$dfs(i,j,k)=-\infty j=0$$

$$dfs(i,j,k)=\{\begin{array}{ll}0& \text{if }i=0,k=0\\ -\infty & \text{if }i=0,k=1\end{array}$$

时间复杂度： $O(n\times k)$

C++代码：

class Solution {
public:
    int maxProfit(int k, vector<int>& prices) {
        int n = prices.size();
        int f[n + 1][k + 2][2];
        memset(f,0x80,sizeof f);
        for(int j = 1;j <= k + 1;j++) f[0][j][0] = 0;

        for(int i = 1;i <= n;i++){
            for(int j = 1;j <= k + 1;j++){
                f[i][j][0] = max(f[i- 1][j][0],f[i - 1][j][1] + prices[i - 1]);
                f[i][j][1] = max(f[i - 1][j][1] , f[i - 1][j - 1][0] - prices[i - 1]);
            }
        }

        return f[n][k+1][0];
    }
};

解法三：动态规划 + 空间优化

我们可以优化掉第一维的空间，同时为了保证数据不被污染，我们可以借鉴 01背包优化空间的方式——倒序遍历。

时间复杂度： $O(n\times k)$

C++代码：

class Solution {
public:
    int maxProfit(int k, vector<int>& prices) {
        int n = prices.size();
        int f[k + 2][2];
        memset(f,0x80,sizeof f);
        for(int j = 1;j <= k + 1;j++) f[j][0] = 0;

        for(int i = 1;i <= n;i++){
            //这里是倒序遍历
            for(int j = k + 1;j >= 1;j--){
            //注意 这里要先求 f[j][1] 再求 f[j][0] ， 否则会出错
                f[j][1] = max(f[j][1] , f[j - 1][0] - prices[i - 1]);
                f[j][0] = max(f[j][0],f[j][1] + prices[i - 1]);
            }
        }

        return f[k+1][0];
    }
};