代码随想录刷题day50｜股票买卖的最佳时机III(至多2次买入和卖出)&股票买卖的最佳时机IV(至多K次买入和卖出)

Yang_Yang_66666

已于 2024-04-10 20:00:23 修改

阅读量675

点赞数 26

分类专栏：算法文章标签：算法

于 2024-04-10 19:57:35 首次发布

本文链接：https://blog.csdn.net/yang_yang_66666/article/details/137607772

版权

算法专栏收录该内容

54 篇文章 1 订阅

订阅专栏

day50学习内容

day50主要内容

股票买卖的最佳时机III–至多2次买入和卖出
股票买卖的最佳时机IV–至多K次买入和卖出

声明
本文思路和文字，引用自《代码随想录》

一、股票买卖的最佳时机III–至多2次买入和卖出

123.原题链接

1.1、动态规划五部曲

1.1.1、确定dp数组（dp table）以及下标的含义

dp[i][j] 代表的是在第 i 天结束时，根据不同的交易状态（即 j），所能达到的最大利润。这个动态规划表通过不断更新这些状态，帮助我们找到在规定的交易次数内（本题为两次）能获得的最大利润。

1.1.2、确定递推公式

对于每一天 i 和每个状态 j，如下计算 dp[i][j]：

没有操作 (j = 0): 这个状态实际上不参与计算，因为我们总是从第一次买入开始计算，但如果要表示它的话，可以认为它是 dp[i][0] = 0。
第一次买入 (j = 1):

dp[i][1]=max(dp[i−1][1],−prices[i])

这意味着第一次买入的最大利润是上一天已经买入的最大利润和今天买入（当前价格的负值，因为我们支付了这么多钱）之间的较大者。

第一次卖出 (j = 2):

dp[i][2]=max(dp[i−1][2],dp[i−1][1]+prices[i])

第一次卖出的最大利润是上一天卖出的最大利润和今天卖出（即上一天买入的最大利润加上今天的价格）之间的较大者。

第二次买入 (j = 3):

dp[i][3]=max(dp[i−1][3],dp[i−1][2]−prices[i])

第二次买入的最大利润是上一天第二次买入的最大利润和上一天第一次卖出后再今天买入（上一天卖出的最大利润减去今天的价格）之间的较大者。

第二次卖出 (j = 4):

dp[i][4]=max(dp[i−1][4],dp[i−1][3]+prices[i])

第二次卖出的最大利润是上一天第二次卖出的最大利润和上一天第二次买入后今天卖出（上一天第二次买入的最大利润加上今天的价格）之间的较大者。

通过这些递推公式，我们能够从第一天遍历到最后一天，同时更新每天的五个状态，最终得到完成两次交易的最大利润，即 dp[n-1][4]，其中 n 是给定价格数组的长度。

1.1.3、 dp数组如何初始化

在第一天，我们可以选择买入股票，所以 dp[0][1] 和 dp[0][3] 都被初始化为 -prices[0]，
这表示第一天买入股票的成本。其他状态的利润在第一天都是0（因为我们还没有进行任何卖出操作）

1.1.4、确定遍历顺序

从小到大遍历

1.2、代码

class Solution {
    public int maxProfit(int[] prices) {
        int len = prices.length;
        if (prices.length == 0)
            return 0;

        /*
         * 定义 5 种状态:
         * 0: 没有操作, 1: 第一次买入, 2: 第一次卖出, 3: 第二次买入, 4: 第二次卖出
         */
        int[][] dp = new int[len][5];
        dp[0][1] = -prices[0];
        dp[0][3] = -prices[0];

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

        return dp[len - 1][4];
    }
}

1.2.1、如何理解这段代码

问题定义：给定一个数组 prices，其中 prices[i] 是第 i 天的股票价格。目标是找出最多进行两次交易（买入和卖出算一次交易）能获得的最大利润。注意，第二次买入必须在第一次卖出之后。
动态规划状态定义：定义一个二维数组 dp[len][5]，其中 len 是给定价格数组的长度。dp[i][j] 表示第 i 天结束时处于五种状态之一的最大利润：
- j = 0：没有进行任何操作。
- j = 1：进行了第一次买入操作。
- j = 2：进行了第一次卖出操作。
- j = 3：进行了第二次买入操作。
- j = 4：进行了第二次卖出操作。
初始化：在第一天，我们可以选择买入股票，所以 dp[0][1] 和 dp[0][3] 都被初始化为 -prices[0]，这表示第一天买入股票的成本。其他状态的利润在第一天都是0（因为我们还没有进行任何卖出操作），但代码中省略了这部分初始化，因为Java数组默认初始化为0。
状态转移方程：从第二天开始，我们根据前一天的状态更新当前天的状态：
- dp[i][1]：第一次买入的最大利润，可能是前一天已经买入，或者今天才买入，取二者的较大值。
- dp[i][2]：第一次卖出的最大利润，可能是前一天已经卖出，或者今天卖出（今天卖出的话，利润是前一天买入的利润加上今天的价格）。
- dp[i][3]：第二次买入的最大利润，可能是前一天已经买入，或者今天买入（今天买入的话，利润是前一天第一次卖出的利润减去今天的价格）。
- dp[i][4]：第二次卖出的最大利润，可能是前一天已经卖出，或者今天卖出（今天卖出的话，利润是前一天第二次买入的利润加上今天的价格）。
输出：最终的答案是 dp[len - 1][4]，即最后一天结束时，完成两次买卖操作的最大利润。

通过动态规划表来追踪并更新每一天可能的最大利润，从而找到最多进行两次交易所能获得的最大利润。

二、股票买卖的最佳时机IV–至多K次买入和卖出

188.原题链接

2.1、动态规划五部曲

2.1.1、确定dp数组（dp table）以及下标的含义

dp[len][k*2 + 1]：一个二维数组，len 是天数，k*2 + 1 是可能的交易状态数量。由于每次交易包括买入和卖出两个操作，因此共有 k*2 个操作状态，加上一个初始的没有操作状态，总共是 k*2 + 1 状态。
对于 dp[i][j]：
- 当 j 为0时，表示没有进行任何操作。
- 当 j 为奇数时，表示第 (j+1)/2 次交易持有股票（即买入状态）。
- 当 j 为偶数时，表示第 j/2 次交易不持有股票（即卖出状态）。

2.1.2、确定递推公式

对于第 i 天（i > 0），遍历所有交易状态 j，根据 j 的奇偶性，分别更新买入状态和卖出状态的最大利润：

买入状态（j 为奇数）：dp[i][j] = Math.max(dp[i - 1][j], dp[i - 1][j - 1] - prices[i])
- 如果在第 i 天买入股票，则最大利润是前一天同状态的利润和前一天卖出状态的利润减去今天的价格中的较大值。
卖出状态（j 为偶数）：dp[i][j] = Math.max(dp[i - 1][j], dp[i - 1][j - 1] + prices[i])
- 如果在第 i 天卖出股票，则最大利润是前一天同状态的利润和前一天买入状态的利润加上今天的价格中的较大值。

2.1.3、 dp数组如何初始化

对于第一天（i=0）：

没有进行任何交易的利润是0，即 dp[0][0] = 0。
对于所有的买入状态（j 为奇数），初始化为 -prices[0]，因为如果在第一天买入股票，则损失了 prices[0] 的金额。

2.1.4、确定遍历顺序

从小到大遍历

2.1.5、输出结果

最终的结果是 dp[len - 1][k*2]，即最后一天，进行完 k 次交易（全部卖出）后的最大利润。

通过这种方法，代码动态地计算在每一天结束时，根据不同交易次数和买卖状态下的最大利润，最终找到在给定交易次数限制下能够获得的最大利润。

2.2、代码

class Solution {
    public int maxProfit(int k, int[] prices) {
        if (prices.length == 0) return 0;

        // [天数][股票状态]
        // 股票状态: 奇数表示第 k 次交易持有/买入, 偶数表示第 k 次交易不持有/卖出, 0 表示没有操作
        int len = prices.length;
        int[][] dp = new int[len][k*2 + 1];
        
        for (int i = 1; i < k*2; i += 2) {
            dp[0][i] = -prices[0];
        }

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