代码随想录:动态规划|309.最佳买卖股票时机含冷冻期&714. 买卖股票的最佳时机含手续费

希望通过这篇文章能看到你的收获和感悟,或许你有更好的理解与建议与我沟通交流,
希望能看到你的留言,即使一句话也非常有意义

309. Best Time to Buy and Sell Stock with Cooldown

股票问题的核心:分清楚状态和状态如何转化的。

dp存储状态:持有和不持有的两个状态,细分为4个状态。

  • 持有状态: 0.今天买入或已经买入
  • 不持有状态: 1.今天卖出
    2.冷冻期 (昨日卖出)
    3.过了冷冻期 (早已卖出

而后还可以合并为3个状态,将dp[1]和dp[2]合并为一个状态。 即:不持有 = 没过冷冻期+过了冷冻期。 怎么好理解怎么去想。而且你完全可以把持有状态换成买入状态。

/**
 * @file 309. Best Time to Buy and Sell Stock with Cooldown.cpp
 * @brief Best Time to Buy and Sell Stock with Cooldown
 * can complete many transactions but must sell the stock before buy again.
 * \attention cooldown one day
 * @author Chris
 * @date 2023-12-28
 * @see https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-with-cooldown/description/
 */

#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
#include <algorithm>
#include <iostream>
#include <vector>
#include "../include/doctest.h"

using namespace std;

class Solution {
 public:
  /**
   * @brief 动态规划
   * 状态: 持有状态: 0.今天买入,或已经买入
   *     不持有状态: 1.今天卖出
   *               2.冷冻期 (昨日卖出)
   *               3.过了冷冻期 (早已卖出)
   */
  int maxProfit(vector<int> &prices) {
    int n = prices.size();
    vector<vector<int>> dp(n, vector<int>(4));
    dp[0][0] = -prices[0];
    for (int i = 1; i < n; ++i) {
      //! 0.持有 = 已经持有,继续保持状态 |(昨日冷冻期or过了冷冻期)今天买
      dp[i][0] = max(dp[i - 1][0], max(dp[i - 1][2], dp[i - 1][3]) - prices[i]);
      //! 1.今日卖出 = 昨日持有,今天卖
      dp[i][1] = dp[i - 1][0] + prices[i];
      //! 2.冷冻期 = 昨日卖出
      dp[i][2] = dp[i - 1][1];
      //! 3.过了冷冻期 = 昨天过了冷冻期,继续处于这个状态|昨日冷冻期
      dp[i][3] = max(dp[i - 1][3], dp[i - 1][2]);
    }
    return *max_element(dp.back().begin() + 1, dp.back().end());
  }
};
/// @fn test function
TEST_CASE("Testing function") {
  Solution s;
  SUBCASE("case 1") {
    vector<int> prices1 = {1, 2, 3, 0, 2};
    CHECK(s.maxProfit(prices1) == 3);
  }
  SUBCASE("case 2") {
    vector<int> prices2 = {1};
    CHECK(s.maxProfit(prices2) == 0);
  }
}

vscode编辑器,doxygen document插件自动生成的doxygen注释语法
使用的doctest.h单元测试库
clangd语言服务器
代码风格clang-format格式based Google

714. Best Time to Buy and Sell Stock with Transaction Fee

这一题很简单,就加了个一个手续费。

dp[i]含义 第i天手里最大现金

两个状态:

  • dp[i][0]持有状态
  • dp[i][1]不持有股票状态

递推公式: 卖的时候交手续费

  • 持有: 1。保持持有状态 2。昨天不持有,今天买入
    dp[i][0] = max(dp[i-1][0], dp[i][1] - prices[i])
  • 不持有: 1。保持不持有状态 2。昨天持有,今天卖出。
    dp[i][1] = max(dp[i-1][1], dp[i][0] + prices[i] - fee)

初始化:

第一天买入 dp[0][0] = -prices[0]
dp[0][1] = 0;

递推顺序:第二天开始从前往后

/**
 * @file 714. Best Time to Buy and Sell Stock with Transaction Fee.cpp
 * @brief 714. Best Time to Buy and Sell Stock with Transaction Fee
 * \attention have transaction fee
 * @author Chris
 * @date 2023-12-28
 * @see https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-with-transaction-fee/
 */
#include <vector>
using namespace std;
class Solution {
 public:
  int maxProfit(vector<int>& prices, int fee) {
    vector<vector<int>> dp(prices.size(), vector<int>(2));
    // dp[i][0] 持有股票, dp[i][1] 不持有股票
    dp[0][0] = -prices[0];
    for (int i = 1; i < prices.size(); ++i) {
      //  持有  = 保持持有状态 | 不持有,今日买入
      dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] - prices[i]);
      // 不持有 = 保持不持有状态 | 持有状态,今日卖出 - 手续费
      dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] + prices[i] - fee);
    }
    return dp.back().back();
  }
};

贪心算法

无限次交易, 一次大额交易可以转化成小额度连续交易,且当天卖了可以当天再买。

比如[1, 2, 3, 4], 第一天买入第四天卖出,相当于连续操作:第一天买-第二天卖;第二天买-第三天卖;第三天买-第四天买。 (2-1) + (3-2) + (4-3) - fee

2个操作,
    1.买入 遇到最低点记录,买入点
    2.卖出 价格大于(最低价格+手续费)就可卖出, 连续交易,有差价就交易

如果价格单调递增,会进行连续交易,那么minPrice存储的就是当前prices[i]价格,

当记录价格时减去手续费 minPrice = prices[i] - fee;

这样可以避免扣除中间多余的手续费。
除了第一次交易,之后的交易为

res += prices[i] - (prices[i-1] - fee) -fee = prices[i]-prices[i-1]

这样就没有手续费啦!一次连续的交易就扣除了一次手续费。

/// @brief 贪心算法
class Solution2 {
 public:
  /** 2个操作:
   *     买入: 遇到最低点记录,买入点
   *     卖出: 价格大于(最低价格+手续费)就可卖出, 连续交易,有差价就赚
   */
  int maxProfit(vector<int>& prices, int fee) {
    vector<vector<int>> dp(prices.size(), vector<int>(2));
    auto greedy = [](vector<int> prices, int fee) {
      int res = 0;
      int minPrice = prices[0];  ///< 记录最低价
      for (int i = 1; i < prices.size(); ++i) {
        /// 记录最低价,这是我们买入是价格
        if (prices[i] < minPrice) minPrice = prices[i];

        /// 只要有的赚我们就卖了再买,进行连续小额交易,==
        /// 一次大额度、高差价交易。 但是我们只要扣除最后一次手续费即可。
        if (prices[i] > minPrice + fee) {
          res += prices[i] - minPrice - fee;
          /// 如果单调递增,进行连续交易,那么minPrice存储的就是当前prices[i]价格
          /// 这可以避免扣除中间多余的手续费
          minPrice = prices[i] - fee;  ///< 记录当前价格
        }
      }
      return res;
    };
    return greedy(prices, fee);
  }
};

综上所述,可以看出来贪心算法就是找到局部最小值和局部最大值,最小值-最大值,累加起来,就是最大收益。 也可以理解为累加单调递增的区间差值

  • 10
    点赞
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值