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];
}

你可能感兴趣的:(数据结构与算法(一刷),动态规划,算法)