代码随想录算法训练营29期|day55 任务以及具体安排

第九章 动态规划part12

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

    java 复制代码
    class Solution {
        public int maxProfit(int[] prices) {
            //0代表持股票,1代表保持卖出状态,2代表卖出股票。3代表冷冻
            int[][] dp = new int[prices.length][4];
            dp[0][0] = -prices[0];
            for(int i = 1 ; i < prices.length ; i++){
                dp[i][0] = Math.max(dp[i-1][0], Math.max(dp[i-1][1]-prices[i], dp[i-1][3]-prices[i]));
                dp[i][1] = Math.max(dp[i-1][1], dp[i-1][3]);
                dp[i][2] = dp[i-1][0] + prices[i];
                dp[i][3] = dp[i-1][2];
            }
            return Math.max(dp[prices.length-1][1], Math.max(dp[prices.length-1][2], dp[prices.length-1][3]));
        }
    }

    思路:分为四种状态进行讨论,所以需要二维数组,0代表持有股票的最大金额,1代表保持卖出状态的最大金额,2表示卖出股票的最大金额,3表示冷冻的最大金额,然后进行递推公式的推导,进行dp数组的初始化。

#卖股票的最佳时机

动态规划:121.买卖股票的最佳时机 (opens new window)股票只能买卖一次,问最大利润

【贪心解法】

取最左最小值,取最右最大值,那么得到的差值就是最大利润,代码如下:

  class Solution {
  public:
      int maxProfit(vector<int>& prices) {
          int low = INT_MAX;
          int result = 0;
          for (int i = 0; i < prices.size(); i++) {
              low = min(low, prices[i]);  // 取最左最小价格
              result = max(result, prices[i] - low); // 直接取最大区间利润
          }
          return result;
      }
  };

【动态规划】

  • dp[i][0] 表示第i天持有股票所得现金。

  • dp[i][1] 表示第i天不持有股票所得现金。

  • 如果第i天持有股票即dp[i][0], 那么可以由两个状态推出来

  • 第i-1天就持有股票,那么就保持现状,所得现金就是昨天持有股票的所得现金 即:dp[i - 1][0]

  • 第i天买入股票,所得现金就是买入今天的股票后所得现金即:-prices[i] 所以dp[i][0] = max(dp[i - 1][0], -prices[i]);

  • 如果第i天不持有股票即dp[i][1], 也可以由两个状态推出来

  • 第i-1天就不持有股票,那么就保持现状,所得现金就是昨天不持有股票的所得现金 即:dp[i - 1][1]

  • 第i天卖出股票,所得现金就是按照今天股票佳价格卖出后所得现金即:prices[i] + dp[i - 1][0] 所以dp[i][1] = max(dp[i - 1][1], prices[i] + dp[i - 1][0]);

  • 代码如下:

    // 版本一
    class Solution {
    public:
        int maxProfit(vector<int>& prices) {
            int len = prices.size();
            if (len == 0) return 0;
            vector<vector<int>> dp(len, vector<int>(2));
            dp[0][0] -= prices[0];
            dp[0][1] = 0;
            for (int i = 1; i < len; i++) {
                dp[i][0] = max(dp[i - 1][0], -prices[i]);
                dp[i][1] = max(dp[i - 1][1], prices[i] + dp[i - 1][0]);
            }
            return dp[len - 1][1];
        }
    };
    
  • 时间复杂度:O(n)

  • 空间复杂度:O(n)

  • 使用滚动数组,代码如下:

    // 版本二
    class Solution {
    public:
        int maxProfit(vector<int>& prices) {
            int len = prices.size();
            vector<vector<int>> dp(2, vector<int>(2)); // 注意这里只开辟了一个2 * 2大小的二维数组
            dp[0][0] -= prices[0];
            dp[0][1] = 0;
            for (int i = 1; i < len; i++) {
                dp[i % 2][0] = max(dp[(i - 1) % 2][0], -prices[i]);
                dp[i % 2][1] = max(dp[(i - 1) % 2][1], prices[i] + dp[(i - 1) % 2][0]);
            }
            return dp[(len - 1) % 2][1];
        }
    };
    
  • 时间复杂度:O(n)

  • 空间复杂度:O(1)

#买卖股票的最佳时机II

动态规划:122.买卖股票的最佳时机II (opens new window)可以多次买卖股票,问最大收益。

【贪心解法】

收集每天的正利润便可,代码如下:

  class Solution {
  public:
      int maxProfit(vector<int>& prices) {
          int result = 0;
          for (int i = 1; i < prices.size(); i++) {
              result += max(prices[i] - prices[i - 1], 0);
          }
          return result;
      }
  };
  • 时间复杂度:O(n)

  • 空间复杂度:O(1)

  • 【动态规划】

    dp数组定义:

  • dp[i][0] 表示第i天持有股票所得现金

  • dp[i][1] 表示第i天不持有股票所得最多现金

  • 如果第i天持有股票即dp[i][0], 那么可以由两个状态推出来

  • 第i-1天就持有股票,那么就保持现状,所得现金就是昨天持有股票的所得现金 即:dp[i - 1][0]

  • 第i天买入股票,所得现金就是昨天不持有股票的所得现金减去 今天的股票价格 即:dp[i - 1][1] - prices[i]

  • 注意这里和121. 买卖股票的最佳时机 (opens new window)唯一不同的地方,就是推导dp[i][0]的时候,第i天买入股票的情况

    121. 买卖股票的最佳时机 (opens new window)中,因为股票全程只能买卖一次,所以如果买入股票,那么第i天持有股票即dp[i][0]一定就是 -prices[i]。

    而本题,因为一只股票可以买卖多次,所以当第i天买入股票的时候,所持有的现金可能有之前买卖过的利润。

    代码如下:(注意代码中的注释,标记了和121.买卖股票的最佳时机唯一不同的地方)

    class Solution {
    public:
        int maxProfit(vector<int>& prices) {
            int len = prices.size();
            vector<vector<int>> dp(len, vector<int>(2, 0));
            dp[0][0] -= prices[0];
            dp[0][1] = 0;
            for (int i = 1; i < len; i++) {
                dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] - prices[i]); // 注意这里是和121. 买卖股票的最佳时机唯一不同的地方。
                dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] + prices[i]);
            }
            return dp[len - 1][1];
        }
    };
    
  • 时间复杂度:O(n)

  • 空间复杂度:O(n)

#买卖股票的最佳时机III

动态规划:123.买卖股票的最佳时机III (opens new window)最多买卖两次,问最大收益。

【动态规划】

一天一共就有五个状态,

  • 没有操作

  • 第一次买入

  • 第一次卖出

  • 第二次买入

  • 第二次卖出

  • dp[i][j]中 i表示第i天,j为 [0 - 4] 五个状态,dp[i][j]表示第i天状态j所剩最大现金。

    达到dp[i][1]状态,有两个具体操作:

  • 操作一:第i天买入股票了,那么dp[i][1] = dp[i-1][0] - prices[i]

  • 操作二:第i天没有操作,而是沿用前一天买入的状态,即:dp[i][1] = dp[i - 1][1]

  • dp[i][1] = max(dp[i-1][0] - prices[i], dp[i - 1][1]);

    同理dp[i][2]也有两个操作:

  • 操作一:第i天卖出股票了,那么dp[i][2] = dp[i - 1][1] + prices[i]

  • 操作二:第i天没有操作,沿用前一天卖出股票的状态,即:dp[i][2] = dp[i - 1][2]

  • 所以dp[i][2] = max(dp[i - 1][1] + prices[i], dp[i - 1][2])

    同理可推出剩下状态部分:

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

    代码如下:

    // 版本一
    class Solution {
    public:
        int maxProfit(vector<int>& prices) {
            if (prices.size() == 0) return 0;
            vector<vector<int>> dp(prices.size(), vector<int>(5, 0));
            dp[0][1] = -prices[0];
            dp[0][3] = -prices[0];
            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]);
            }
            return dp[prices.size() - 1][4];
        }
    };
    
  • 时间复杂度:O(n)

  • 空间复杂度:O(n × 5)

  • 当然,大家可以看到力扣官方题解里的一种优化空间写法,我这里给出对应的C++版本:

    // 版本二
    class Solution {
    public:
        int maxProfit(vector<int>& prices) {
            if (prices.size() == 0) return 0;
            vector<int> dp(5, 0);
            dp[1] = -prices[0];
            dp[3] = -prices[0];
            for (int i = 1; i < prices.size(); i++) {
                dp[1] = max(dp[1], dp[0] - prices[i]);
                dp[2] = max(dp[2], dp[1] + prices[i]);
                dp[3] = max(dp[3], dp[2] - prices[i]);
                dp[4] = max(dp[4], dp[3] + prices[i]);
            }
            return dp[4];
        }
    };
    
  • 时间复杂度:O(n)

  • 空间复杂度:O(1)

  • 这种写法看上去简单,其实思路很绕,不建议大家这么写,这么思考,很容易把自己绕进去! 对于本题,把版本一的写法研究明白,足以!

    #买卖股票的最佳时机IV

    动态规划:188.买卖股票的最佳时机IV (opens new window)最多买卖k笔交易,问最大收益。

    使用二维数组 dp[i][j] :第i天的状态为j,所剩下的最大现金是dp[i][j]

    j的状态表示为:

  • 0 表示不操作

  • 1 第一次买入

  • 2 第一次卖出

  • 3 第二次买入

  • 4 第二次卖出

  • .....

  • 除了0以外,偶数就是卖出,奇数就是买入

  • 确定递推公式

  • 达到dp[i][1]状态,有两个具体操作:

  • 操作一:第i天买入股票了,那么dp[i][1] = dp[i - 1][0] - prices[i]

  • 操作二:第i天没有操作,而是沿用前一天买入的状态,即:dp[i][1] = dp[i - 1][1]

  • dp[i][1] = max(dp[i - 1][0] - prices[i], dp[i - 1][1]);

    同理dp[i][2]也有两个操作:

  • 操作一:第i天卖出股票了,那么dp[i][2] = dp[i - 1][1] + prices[i]

  • 操作二:第i天没有操作,沿用前一天卖出股票的状态,即:dp[i][2] = dp[i - 1][2]

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

    同理可以类比剩下的状态,代码如下:

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

    整体代码如下:

    class Solution {
    public:
        int maxProfit(int k, vector<int>& prices) {
    
            if (prices.size() == 0) return 0;
            vector<vector<int>> dp(prices.size(), vector<int>(2 * k + 1, 0));
            for (int j = 1; j < 2 * k; j += 2) {
                dp[0][j] = -prices[0];
            }
            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]);
                }
            }
            return dp[prices.size() - 1][2 * k];
        }
    };
    

    当然有的解法是定义一个三维数组dp[i][j][k],第i天,第j次买卖,k表示买还是卖的状态,从定义上来讲是比较直观。但感觉三维数组操作起来有些麻烦,直接用二维数组来模拟三维数组的情况,代码看起来也清爽一些。

    #最佳买卖股票时机含冷冻期

    动态规划:309.最佳买卖股票时机含冷冻期 (opens new window)可以多次买卖但每次卖出有冷冻期1天。

    相对于动态规划:122.买卖股票的最佳时机II (opens new window),本题加上了一个冷冻期。

    动态规划:122.买卖股票的最佳时机II (opens new window)中有两个状态,持有股票后的最多现金,和不持有股票的最多现金。本题则可以花费为四个状态

    dp[i][j]:第i天状态为j,所剩的最多现金为dp[i][j]。

    具体可以区分出如下四个状态:

  • 状态一:买入股票状态(今天买入股票,或者是之前就买入了股票然后没有操作)

  • 卖出股票状态,这里就有两种卖出股票状态

    • 状态二:两天前就卖出了股票,度过了冷冻期,一直没操作,今天保持卖出股票状态
    • 状态三:今天卖出了股票
  • 状态四:今天为冷冻期状态,但冷冻期状态不可持续,只有一天!

  • 达到买入股票状态(状态一)即:dp[i][0],有两个具体操作:

  • 操作一:前一天就是持有股票状态(状态一),dp[i][0] = dp[i - 1][0]

  • 操作二:今天买入了,有两种情况

    • 前一天是冷冻期(状态四),dp[i - 1][3] - prices[i]
    • 前一天是保持卖出股票状态(状态二),dp[i - 1][1] - prices[i]
  • 所以操作二取最大值,即:max(dp[i - 1][3], dp[i - 1][1]) - prices[i]

    那么dp[i][0] = max(dp[i - 1][0], max(dp[i - 1][3], dp[i - 1][1]) - prices[i]);

    达到保持卖出股票状态(状态二)即:dp[i][1],有两个具体操作:

  • 操作一:前一天就是状态二

  • 操作二:前一天是冷冻期(状态四)

  • dp[i][1] = max(dp[i - 1][1], dp[i - 1][3]);

    达到今天就卖出股票状态(状态三),即:dp[i][2] ,只有一个操作:

  • 操作一:昨天一定是买入股票状态(状态一),今天卖出

  • 即:dp[i][2] = dp[i - 1][0] + prices[i];

    达到冷冻期状态(状态四),即:dp[i][3],只有一个操作:

  • 操作一:昨天卖出了股票(状态三)

  • p[i][3] = dp[i - 1][2];

    综上分析,递推代码如下:

    dp[i][0] = max(dp[i - 1][0], max(dp[i - 1][3]- prices[i], dp[i - 1][1]) - prices[i];
    dp[i][1] = max(dp[i - 1][1], dp[i - 1][3]);
    dp[i][2] = dp[i - 1][0] + prices[i];
    dp[i][3] = dp[i - 1][2];
    

    整体代码如下:

    class Solution {
    public:
        int maxProfit(vector<int>& prices) {
            int n = prices.size();
            if (n == 0) return 0;
            vector<vector<int>> dp(n, vector<int>(4, 0));
            dp[0][0] -= prices[0]; // 持股票
            for (int i = 1; i < n; i++) {
                dp[i][0] = max(dp[i - 1][0], max(dp[i - 1][3], dp[i - 1][1]) - prices[i]);
                dp[i][1] = max(dp[i - 1][1], dp[i - 1][3]);
                dp[i][2] = dp[i - 1][0] + prices[i];
                dp[i][3] = dp[i - 1][2];
            }
            return max(dp[n - 1][3],max(dp[n - 1][1], dp[n - 1][2]));
        }
    };
    
  • 时间复杂度:O(n)

  • 空间复杂度:O(n)

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

动态规划:714.买卖股票的最佳时机含手续费 (opens new window)可以多次买卖,但每次有手续费。

相对于动态规划:122.买卖股票的最佳时机II (opens new window),本题只需要在计算卖出操作的时候减去手续费就可以了,代码几乎是一样的。

唯一差别在于递推公式部分,所以本篇也就不按照动规五部曲详细讲解了,主要讲解一下递推公式部分。

这里重申一下dp数组的含义:

dp[i][0] 表示第i天持有股票所省最多现金。 dp[i][1] 表示第i天不持有股票所得最多现金

如果第i天持有股票即dp[i][0], 那么可以由两个状态推出来

  • 第i-1天就持有股票,那么就保持现状,所得现金就是昨天持有股票的所得现金 即:dp[i - 1][0]

  • 第i天买入股票,所得现金就是昨天不持有股票的所得现金减去 今天的股票价格 即:dp[i - 1][1] - prices[i]

  • 所以:dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] - prices[i]);

    在来看看如果第i天不持有股票即dp[i][1]的情况, 依然可以由两个状态推出来

  • 第i-1天就不持有股票,那么就保持现状,所得现金就是昨天不持有股票的所得现金 即:dp[i - 1][1]

  • 第i天卖出股票,所得现金就是按照今天股票价格卖出后所得现金,注意这里需要有手续费了即:dp[i - 1][0] + prices[i] - fee

  • 所以:dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] + prices[i] - fee);

    本题和动态规划:122.买卖股票的最佳时机II (opens new window)的区别就是这里需要多一个减去手续费的操作

    以上分析完毕,代码如下:

    class Solution {
    public:
        int maxProfit(vector<int>& prices, int fee) {
            int n = prices.size();
            vector<vector<int>> dp(n, vector<int>(2, 0));
            dp[0][0] -= prices[0]; // 持股票
            for (int i = 1; i < n; 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 max(dp[n - 1][0], dp[n - 1][1]);
        }
    };
    
  • 时间复杂度:O(n)

  • 空间复杂度:O(n)

相关推荐
百事老饼干2 分钟前
Java[面试题]-真实面试
java·开发语言·面试
customer0810 分钟前
【开源免费】基于SpringBoot+Vue.JS医院管理系统(JAVA毕业设计)
java·vue.js·spring boot·后端·spring cloud·开源·intellij-idea
2402_8575893620 分钟前
SpringBoot框架:作业管理技术新解
java·spring boot·后端
HBryce2424 分钟前
缓存-基础概念
java·缓存
一只爱打拳的程序猿38 分钟前
【Spring】更加简单的将对象存入Spring中并使用
java·后端·spring
幸运超级加倍~39 分钟前
软件设计师-上午题-16 算法(4-5分)
笔记·算法
杨荧40 分钟前
【JAVA毕业设计】基于Vue和SpringBoot的服装商城系统学科竞赛管理系统
java·开发语言·vue.js·spring boot·spring cloud·java-ee·kafka
minDuck42 分钟前
ruoyi-vue集成tianai-captcha验证码
java·前端·vue.js
yannan201903131 小时前
【算法】(Python)动态规划
python·算法·动态规划