Day50｜动态规划part12：309.最佳买卖股票时机含冷冻期、714.买卖股票的最佳时机含手续费

309. 买卖股票的最佳时机含冷冻期

leetcode链接：力扣题目链接

视频链接：动态规划来决定最佳时机，这次有冷冻期！| LeetCode：309.买卖股票的最佳时机含冷冻期

给定一个整数数组 prices，其中第 prices[i] 表示第 i 天的股票价格 。​

设计一个算法计算出最大利润。在满足以下约束条件下，你可以尽可能地完成更多的交易（多次买卖一支股票）:

卖出股票后，你无法在第二天买入股票 (即冷冻期为 1 天)。
注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

示例 1:

输入: prices = [1,2,3,0,2]
输出: 3 
解释: 对应的交易状态为: [买入, 卖出, 冷冻期, 买入, 卖出]
示例 2:

输入: prices = [1]
输出: 0

这题相比买卖股票II 添加了冷冻的限制，但其实k还是无穷的，把II的代码修改一下即可：

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        vector<vector<int>> dp (prices.size(),vector<int>(2));
        int cooldown = 1;//本题的冷却期为1天
        dp[0][0] = 0;
        dp[0][1] = -prices[0];
        for(int i = 1; i < prices.size(); i++){
            if(i - cooldown - 1 < 0){//防止数组越界，或者说在这段时间内i很短，不需要冷静期
                dp[i][0] = max(dp[i-1][0], dp[i-1][1] + prices[i]);
                dp[i][1] = max(dp[i-1][1], -prices[i]);
                continue;
            }
            dp[i][0] = max(dp[i-1][0], dp[i-1][1] + prices[i]);
            dp[i][1] = max(dp[i-1][1], dp[i- cooldown - 1][0] -prices[i]);

        }
        return dp[prices.size() - 1][0];
    }
};

注意这里的dp[i][1]有变化，分析一下：dp[i][1]表示到状态1的两种情况，第一个是rest，从前一天开始就持有股票且不仍然不卖出，此时就是dp[i - 1][1]，第二种情况是从前i - cooldown-1天买入，因为有冷冻期，故经过cooldown天才能在第二天买入。

714.买卖股票的最佳时机含手续费

leetcode链接：力扣题目链接

视频链接：动态规划来决定最佳时机，这次含手续费！| LeetCode：714.买卖股票的最佳时机含手续费

给定一个整数数组 prices，其中第 prices[i] 表示第 i 天的股票价格 。​

设计一个算法计算出最大利润。在满足以下约束条件下，你可以尽可能地完成更多的交易（多次买卖一支股票）:

卖出股票后，你无法在第二天买入股票 (即冷冻期为 1 天)。
注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

示例 1:

输入: prices = [1,2,3,0,2]
输出: 3 
解释: 对应的交易状态为: [买入, 卖出, 冷冻期, 买入, 卖出]
示例 2:

输入: prices = [1]
输出: 0

这题加入了手续费的限制，k还是无限大，还是买卖股票II的变体。最终代码：

class Solution {
public:
    int maxProfit(vector<int>& prices, int fee) {
        vector<vector<int>> dp (prices.size(),vector<int>(2));
        dp[0][0] = 0;
        dp[0][1] = -( prices[0]);
        for(int i = 1; i < prices.size(); i++){
            dp[i][0] = max(dp[i-1][0], dp[i-1][1] + prices[i] - fee);
            dp[i][1] = max(dp[i-1][1], dp[i-1][0] -prices[i]);
        }
        return dp[prices.size() - 1][0];
    }
};

注意这里手续费在一次交易（一次买入，一次卖出）中只需要交一次，故在卖出的时候交手续费就可以了，比较方便。

总结

[外链图片转存中…(img-ZbHyYewC-1693441148143)]

• 买卖股票加入k之后，因为要穷举所有的状态，因此还要加一层循环对k进行穷举。
• 注意三维数组的vector写法：

vector<vector<vector<int>>> dp(prices.size(), vector<vector<int>>
(max_k + 1, vector<int>(2,0)));

• 无论是加入手续费还是冷静期，原理基本还是一样的。略微修改递归公式即可。若与天数相关就改变下标i，若与费用相关就改变price
• 将以上所有的糅合起来的框架：

请你实现如下函数：

int maxProfit_all_in_one(int max_k, int[] prices, int cooldown, int fee);

输入股票价格数组 prices，你最多进行 max_k 次交易，每次交易需要额外消耗 fee 的手续费，而且每次交易之后需要经过 cooldown 天的冷冻期才能进行下一次交易，请你计算并返回可以获得的最大利润。

最终代码：

// 同时考虑交易次数的限制、冷冻期和手续费
int maxProfit_all_in_one(int max_k, vector<int>& prices, int cooldown, int fee) {
    int n = prices.size();
    if (n <= 0) {
        return 0;
    }
    if (max_k > n / 2) {
        // 交易次数 k 没有限制的情况
        return maxProfit_k_inf(prices, cooldown, fee);
    }

    vector<vector<vector<int>>> dp(n, vector<vector<int>>(max_k + 1, vector<int>(2)));
    // k = 0 时的 base case
    for (int i = 0; i < n; i++) {
        dp[i][0][1] = INT_MIN;
        dp[i][0][0] = 0;
    }

    for (int i = 0; i < n; i++) {
        for (int k = max_k; k >= 1; k--) {
            if (i - 1 == -1) {
                // base case 1
                dp[i][k][0] = 0;
                dp[i][k][1] = -prices[i] - fee;
                continue;
            }

            // 包含 cooldown 的 base case
            if (i - cooldown - 1 < 0) {
                // base case 2
                dp[i][k][0] = max(dp[i-1][k][0], dp[i-1][k][1] + prices[i]);
                // 别忘了减 fee
                dp[i][k][1] = max(dp[i-1][k][1], -prices[i] - fee);
                continue;
            }
            dp[i][k][0] = max(dp[i-1][k][0], dp[i-1][k][1] + prices[i]);
            // 同时考虑 cooldown 和 fee
            dp[i][k][1] = max(dp[i-1][k][1], dp[i-cooldown-1][k-1][0] - prices[i] - fee);     
        }
    }
    return dp[n - 1][max_k][0];
}

// k 无限制，包含手续费和冷冻期
int maxProfit_k_inf(vector<int>& prices, int cooldown, int fee) {
    int n = prices.size();
    vector<vector<int>> dp(n, vector<int>(2));
    for (int i = 0; i < n; i++) {
        if (i - 1 == -1) {
            // base case 1
            dp[i][0] = 0;
            dp[i][1] = -prices[i] - fee;
            continue;
        }

        // 包含 cooldown 的 base case
        if (i - cooldown - 1 < 0) {
            // base case 2
            dp[i][0] = max(dp[i-1][0], dp[i-1][1] + prices[i]);
            // 别忘了减 fee
            dp[i][1] = max(dp[i-1][1], -prices[i] - fee);
            continue;
        }
        dp[i][0] = max(dp[i-1][0], dp[i-1][1] + prices[i]);
        // 同时考虑 cooldown 和 fee
        dp[i][1] = max(dp[i-1][1], dp[i-cooldown-1][0] - prices[i] - fee);
    }
    return dp[n - 1][0];
}