羊羊刷题笔记Day50/60 | 第九章 动态规划P11 | 123. 买卖股票的最佳时机III、188. 买卖股票的最佳时机IV

58 阅读5分钟

123 买卖股票的最佳时机Ⅲ

条件为:最多买卖两次股票

✍手写分析

image.png

思路

本题关键在于至多买卖两次,这意味着可以买卖一次,可以买卖两次,也可以不买卖。
接来下我用动态规划五部曲详细分析一下:

  1. 确定dp数组以及下标的含义

一天一共就有五个状态,

  • 没有操作 (其实我们也可以不设置这个状态)
  • 第一次持有股票
  • 第一次不持有股票
  • 第二次持有股票
  • 第二次不持有股票

dp[i][j]中 i表示第i天,j为 [0 - 4] 五个状态,dp[i][j]表示第i天状态j所剩最大现金。
需要注意:dp[i][1],表示的是第i天,买入股票的状态,并不是说一定要第i天买入股票
例如 dp[i][1] ,并不是说 第i天一定买入股票,有可能 第 i-1天 就买入了,那么 dp[i][1] 延续买入股票的这个状态。

  1. 确定递推公式

达到**dp[i][1]**状态,有两个具体操作:

  • 操作一:第i天买入股票了,那么dp[i][1] = dp[i-1][0] - prices[i]
  • 操作二:第i天没有操作,且持有股票即:dp[i][1] = dp[i - 1][1]

所以 dp[i][1] = max(dp[i-1][0] - prices[i], dp[i - 1][1]);
同理**dp[i][2]**也有两个操作:

  • 操作一:第i天卖出股票了,那么dp[i][2] = dp[i - 1][1] + prices[i]
  • 操作二:第i天没有操作,沿用前一天卖出股票的状态,即:dp[i][2] = dp[i - 1][2]

所以dp[i][2] = max(dp[i - 1][1] + prices[i], dp[i - 1][2])
同理可推出剩下状态部分:
dp[i][3] = max(dp[i - 1][3], dp[i - 1][2] - prices[i]);
**dp[i][4] **= max(dp[i - 1][4], dp[i - 1][3] + prices[i]);

  1. dp数组如何初始化

第0天没有操作,这个最容易想到,就是0,即:dp[0][0] = 0;
第0天做第一次买入的操作,dp[0][1] = -prices[0];
第0天做第一次卖出的操作,当天买入,当天卖出,所以dp[0][2] = 0;
第0天第二次买入操作,第0天第一次买入了,第一次卖出了,然后再买入一次(第二次买入)现金就做相应的减少。所以第二次买入操作,初始化为:dp[0][3] = -prices[0];
同理第二次卖出初始化dp[0][4] = 0;

  1. 确定遍历顺序

从递归公式其实已经可以看出,一定是从前向后遍历,因为dp[i],依靠dp[i - 1]的数值。

  1. 举例推导dp数组

以输入[1,2,3,4,5]为例

大家可以看到红色框为最后两次卖出的状态。
现在最大的时候一定是卖出的状态,而两次卖出的状态现金最大一定是最后一次卖出。如果第一次卖出已经是最大值了,那么我们可以在当天立刻买入再立刻卖出。所以dp[4][4]已经包含了dp[4][2]的情况。也就是说第二次卖出手里所剩的钱一定是最多的。
所以最终最大利润是dp[4][4]
以上五部都分析完了,不难写出如下代码:

public int maxProfit(int[] prices) {
    int len = prices.length;
    int[][] dp = new int[len][5];
    dp[0][0] = 0;
    dp[0][1] = -prices[0];
    dp[0][2] = 0;
    dp[0][3] = -prices[0];
    dp[0][4] = 0;

    for (int i = 1; i < len; i++) {
        dp[i][0] = 0;
        dp[i][1] = Math.max(- prices[i], dp[i - 1][1]);
        dp[i][2] = Math.max(dp[i - 1][1] + prices[i], dp[i - 1][2]);
        dp[i][3] = Math.max(dp[i - 1][2] - prices[i], dp[i - 1][3]);
        dp[i][4] = Math.max(dp[i - 1][3] + prices[i], dp[i - 1][4]);
    }

    return dp[len - 1][4];
}
  • 时间复杂度:O(n)
  • 空间复杂度:O(n × 5)

188 买卖股票的最佳时机IV

条件:只能买卖两次 → 只能买卖k次

特殊化 → 一般化

买卖两次思路的延申

动规五部曲分析

动规五部曲,分析如下:

  1. 确定dp数组以及下标的含义

使用二维数组 dp[i][j] :第i天的状态为j,所剩下的最大现金是dp[i][j]
j的状态表示为:

  • 0 表示不操作
  • 1 第一次买入
  • 2 第一次卖出
  • 3 第二次买入
  • 4 第二次卖出
  • 5 第三次.....

规律:除了0以外,偶数就是卖出,奇数就是买入

题目要求是至多有K笔交易,那么j的范围就定义为 2 * k + 1 就可以了。
所以二维dp数组的C++定义为:

int[][] dp = new int[len][2 * k + 1];
  1. 确定递推公式

回顾定义:dp[i][1],表示的是第i天,买入股票的状态,并不是说一定要第i天买入股票。
而2k次买卖本质上都是由以下两种状态组成
达到dp[i][1]状态,有两个具体操作:

  • 操作一:第 i 天买入股票了,那么dp[i][1] = dp[i - 1][0] - prices[i]
  • 操作二:第 i 天没有操作,而是沿用前一天买入的状态,即:dp[i][1] = dp[i - 1][1]

选最大的,所以 dp[i][1] = max(dp[i - 1][0] - prices[i], dp[i - 1][1]);
同理dp[i][2]也有两个操作:

  • 操作一:第 i 天卖出股票了,那么dp[i][2] = dp[i - 1][1] + prices[i]
  • 操作二:第 i 天没有操作,沿用前一天卖出股票的状态,即:dp[i][2] = dp[i - 1][2]

所以dp[i][2] = max(dp[i - 1][1] + prices[i], dp[i - 1][2])
同理可以类比剩下的状态,代码如下:

for (int j = 0; j < 2 * k; j += 2) {
    dp[i][j + 1] = Math.max(dp[i - 1][j] - prices[i], dp[i - 1][j + 1]);
    dp[i][j + 2] = Math.max(dp[i - 1][j + 1] + prices[i], dp[i - 1][j + 2]);
}
  1. dp数组如何初始化

第0天没有操作,这个最容易想到,就是0,即:dp[0][0] = 0;
第0天做第一次买入的操作,dp[0][1] = -prices[0];
第0天做第一次卖出的操作,当天买入,当天卖出,所以dp[0][2] = 0;
第0天第二次买入操作,(第0天第一次买入了,第一次卖出了,然后在买入一次),
初始化为:dp[0][3] = -prices[0];
第二次卖出初始化dp[0][4] = 0;
所以同理可以推出dp[0][j]当j为奇数的时候都初始化为 -prices[0]
代码如下:

// 初始化
for (int j = 1; j < 2 * k; j += 2) {
    dp[0][j] = -prices[0];
}

在初始化的地方同样要类比j为偶数是卖、奇数是买的状态

  1. 确定遍历顺序

从递归公式其实已经可以看出,一定是从前向后遍历,因为dp[i],依靠dp[i - 1]的数值。

  1. 举例推导dp数组

以输入[1,2,3,4,5],k=2为例。

最后一次卖出,一定是利润最大的,dp[prices.size() - 1][2 * k]即红色部分就是最后求解。
以上分析完毕,代码如下:

public int maxProfit(int k, int[] prices) {
    int len = prices.length;
    int[][] dp = new int[len][2 * k + 1];

    // 初始化
    for (int j = 1; j < 2 * k; j += 2) {
        dp[0][j] = -prices[0];
    }

    // 递推公式
    for (int i = 1; i < len; i++) {
        for (int j = 0; j < 2 * k; j += 2) {
            dp[i][j + 1] = Math.max(dp[i - 1][j] - prices[i], dp[i - 1][j + 1]);
            dp[i][j + 2] = Math.max(dp[i - 1][j + 1] + prices[i], dp[i - 1][j + 2]);
        }
    }

    return dp[len - 1][2*k];
}
  • 时间复杂度: O(n * k),其中 n 为 prices 的长度
  • 空间复杂度: O(n * k)

学习资料:

123.买卖股票的最佳时机III

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