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

感觉画质不如…原神

已于 2023-10-07 20:58:52 修改

阅读量121

点赞数 1

分类专栏： Leetcode 文章标签：动态规划记忆化搜索股票问题

于 2023-10-07 20:58:49 首次发布

本文链接：https://blog.csdn.net/m0_74396439/article/details/133654760

版权

Leetcode 专栏收录该内容

441 篇文章 2 订阅

订阅专栏

题目链接

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

题目描述

给你一个整数数组 $p r i ces$ 和一个整数 $k$ ，其中 $p r i ces [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 。

提示：

$\leq k \leq 100$
$\leq prices.length \leq 1000$
$\leq prices[i] \leq 1000$

解法一：记忆化搜索

我们定义 $df s (i, j, 1)$ 为第 $i$ 天结束的时候最多完成 $j$ 笔交易且 持有股票 的最大利润；
我们定义 $df s (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$ 的特殊情况：

$-\infty \qquad j < 0$

$\begin{cases} 0 & \text{if } i < 0,k=0\\ -\infty & \text{if } i<0,k=1 \end{cases}$

时间复杂度： $\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{cases} 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{cases}$

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

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

$\begin{cases} 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{cases}$

此时的边界条件为：

$-\infty \qquad j = 0$

$\begin{cases} 0 & \text{if } i = 0,k=0\\ -\infty & \text{if } i=0,k=1 \end{cases}$

时间复杂度： $\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背包优化空间的方式——倒序遍历。

时间复杂度： $\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];
    }
};