「前端刷题」188.买卖股票的最佳时机 IV（HARD）

持续创作，加速成长！这是我参与「掘金日新计划 · 6 月更文挑战」的第23天，点击查看活动详情

题目(Best Time to Buy and Sell Stock IV)

链接：https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-iv
解决数：1029
通过率：41.8%
标签：数组 动态规划 
相关公司：amazon google bytedance 

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

设计一个算法来计算你所能获取的最大利润。你最多可以完成 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 。

 

提示：

• 0 <= k <= 100
• 0 <= prices.length <= 1000
• 0 <= prices[i] <= 1000

思路

不能同时参加多笔交易，先买入才能卖出，再次买入时，需要先卖出，k >= 0才能进行交易

3种操作操作

• 买入，卖出，不操作

定义状态

  dp[i][k][0]//第i天 交易k次 没有股票
  dp[i][k][1]//第i天 交易k次 有股票

• 其中i表示天数，k表示交易次数，每次交易包含买入和卖出，定义在买入的时候将 k - 1，0表示不持有股票，1表示持有股票

• 最终的最大收益是dp[n - 1][k][0]而不是dp[n - 1][k][1]，因为最后一天卖出肯定比持有收益更高

状态转移方程

// 第i天没有持有股票，分两种情况：
// 1. dp[i - 1][k][0]，i-1天没有持有，第i天不操作。 
// 2. dp[i - 1][k][1] + prices[i] i-1天持有，第i天卖出，第i天手中就没有股票了。
dp[i][k][0] = Math.max(dp[i - 1][k][0], dp[i - 1][k][1] + prices[i])


// 第i天持有股票，分两种情况：
// 1.dp[i - 1][k][1] i-1天持有，第i天不操作
// 2.dp[i - 1][k - 1][0] - prices[i] i-1天没有持有，第i天买入。
dp[i][k][1] = Math.max(dp[i - 1][k][1], dp[i - 1][k - 1][0] - prices[i])

121. 买卖股票的最佳时机 交易次数k=1

状态转移方程

//第i天不持有           第i-1天不持有不操作 第i-1天持有然后卖出
dp[i][1][0] = Math.max(dp[i - 1][1][0], dp[i - 1][1][1] + prices[i])
//第i天持有             第i-1天持有不操作  第i-1天不持有然后买入
dp[i][1][1] = Math.max(dp[i - 1][1][1], dp[i - 1][0][0] - prices[i])
            = Math.max(dp[i - 1][1][1], -prices[i]) // k=0时 dp[i - 1][0][0] = 0

因为k是固定值1，简化如下

dp[i][0] = Math.max(dp[i - 1][0], dp[i - 1][1] + prices[i])
dp[i][1] = Math.max(dp[i - 1][1], -prices[i])

代码

//时间复杂度O(n) 空间复杂度O(n)，dp数组第二维是常数
const maxProfit = function (prices) {
    let n = prices.length;
    let dp = Array.from(new Array(n), () => new Array(2));
    dp[0][0] = 0; //第0天不持有
    dp[0][1] = -prices[0]; //第0天持有
    for (let i = 1; i < n; i++) {
        dp[i][0] = Math.max(dp[i - 1][0], dp[i - 1][1] + prices[i]);
        dp[i][1] = Math.max(dp[i - 1][1], -prices[i]);
    }
    return dp[n - 1][0];
};

状态压缩，dp[i] 只由 dp[i - 1] 递推出来

//时间复杂度O(n) 空间复杂度O(1)
const maxProfit = function (prices) {
    let n = prices.length;
    let dp = Array.from(new Array(n), () => new Array(2));
    dp[0] = 0;
    dp[1] = -prices[0];
    for (let i = 1; i < n; i++) {
        dp[0] = Math.max(dp[0], dp[1] + prices[i]);
        dp[1] = Math.max(dp[1], -prices[i]);
    }
    return dp[0];
};

//变量替代
const maxProfit = function (prices) {
    let n = prices.length;
    let sell = 0;
    let buy = -prices[0];
    for (let i = 1; i < n; i++) {
        sell = Math.max(sell, buy + prices[i]);
        buy = Math.max(buy, -prices[i]);
    }
    return sell;
};