二刷代码随想录——动态规划day50

---

前言

一个本硕双非的小菜鸡，备战24年秋招，计划二刷完卡子哥的刷题计划，加油！
二刷决定精刷了，于是参加了卡子哥的刷题班，训练营为期60天，我一定能坚持下去，迎来两个月后的脱变的，加油！
推荐一手卡子哥的刷题网站，感谢卡子哥。代码随想录

动态规知识点

终于来到了守关boss。。。

动态规划中每一个状态一定是由上一个状态推导出来的

动规是由前一个状态推导出来的，而贪心是局部直接选最优的。

动规五部曲

动态规划一般分为如下五步：

1. 确定dp数组（dp table）以及下标的含义
2. 确定递推公式
3. dp数组如何初始化
4. 确定遍历顺序
5. 举例推导dp数组

        //1. 确定dp数组（dp table）以及下标的含义
        
        //2. 确定递推公式

        //3. dp数组如何初始化

        //4. 确定遍历顺序

        //5. 举例推导dp数组

解题时候多把dp数组打印出来，看看究竟是不是按照自己思路推导的。

写代码之前一定要把状态转移在dp数组的上具体情况模拟一遍，心中有数，确定最后推出的是想要的结果。

然后再写代码，如果代码没通过就打印dp数组，看看是不是和自己预先推导的哪里不一样。

如果打印出来和自己预先模拟推导是一样的，那么就是自己的递归公式、初始化或者遍历顺序有问题了。

如果和自己预先模拟推导的不一样，那么就是代码实现细节有问题。

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

123. 买卖股票的最佳时机 III
Note：难度直线上升，多种情况需考虑

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        if (prices.size() == 0) return 0;
        //1. 确定dp数组（dp table）以及下标的含义
        //重点在于对应情况具体分析，一共五个状态
        //没有操作 （其实我们也可以不设置这个状态）
        //第一次持有股票
        //第一次不持有股票
        //第二次持有股票
        //第二次不持有股票
        //dp[i][j]中 i表示第i天，j为 [0 - 4] 五个状态，dp[i][j]表示第i天状态j所剩最大现金。
        vector<vector<int>> dp(prices.size(), vector<int>(5, 0));
        
        //2. 确定递推公式
        // dp[i][0] = dp[i - 1][0];
        // dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] - prices[i]);
        // dp[i][2] = max(dp[i - 1][2], dp[i - 1][1] + prices[i]);
        // 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]);

        //3. dp数组如何初始化
        dp[0][1] = -prices[0];
        dp[0][3] = -prices[0];

        //4. 确定遍历顺序
        for (int i = 1; i < prices.size(); i++) {
            dp[i][0] = dp[i - 1][0];
            dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] - prices[i]);
            dp[i][2] = max(dp[i - 1][2], dp[i - 1][1] + prices[i]);
            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]);
        }

        //5. 举例推导dp数组
        return dp[prices.size() - 1][4];
    }
};

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

188. 买卖股票的最佳时机 IV
Note：难度直线上升，多种情况需考虑

class Solution {
public:
    int maxProfit(int k, vector<int>& prices) {
        if (prices.size() == 0) return 0;
        //1. 确定dp数组（dp table）以及下标的含义
        //重点在于对应情况具体分析，一共五个状态
        //没有操作 （其实我们也可以不设置这个状态）
        //第一次持有股票
        //第一次不持有股票
        //第二次持有股票
        //第二次不持有股票
        //dp[i][j]中 i表示第i天，j为 [0 - 4] 五个状态，dp[i][j]表示第i天状态j所剩最大现金。
        vector<vector<int>> dp(prices.size(), vector<int>(2 * k + 1, 0));
        
        //2. 确定递推公式
        //dp[i][j + 1] = max(dp[i - 1][j + 1], dp[i - 1][j] - prices[i]);
        //dp[i][j + 2] = max(dp[i - 1][j + 2], dp[i - 1][j + 1] + prices[i]);

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

        //4. 确定遍历顺序
        for (int i = 1;i < prices.size(); i++) {
            for (int j = 0; j < 2 * k - 1; j += 2) {
                dp[i][j + 1] = max(dp[i - 1][j + 1], dp[i - 1][j] - prices[i]);
                dp[i][j + 2] = max(dp[i - 1][j + 2], dp[i - 1][j + 1] + prices[i]);
            }
        }

        //5. 举例推导dp数组
        return dp[prices.size() - 1][2 * k];
    }
};

总结

动态规划法，和分治法极其相似。区别就是，在求解子问题时，会保存该子问题的解，后面的子问题求解时，可以直接拿来计算。