[数据结构与算法] ??思维导图整理大厂面试高频数组21: 股票问题+冷冻期的两种dp数组定义方式力扣309??

开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> 数据结构与算法 -> ??思维导图整理大厂面试高频数组21: 股票问题+冷冻期的两种dp数组定义方式力扣309?? -> 正文阅读

[数据结构与算法]??思维导图整理大厂面试高频数组21: 股票问题+冷冻期的两种dp数组定义方式力扣309??

此专栏文章是对力扣上算法题目各种方法的总结和归纳, 整理出最重要的思路和知识重点并以思维导图形式呈现, 当然也会加上我对导图的详解.

目的是为了更方便快捷的记忆和回忆算法重点(不用每次都重复看题解), 毕竟算法不是做了一遍就能完全记住的. 所以本文适合已经知道解题思路和方法, 想进一步加强理解和记忆的朋友, 并不适合第一次接触此题的朋友(可以根据题号先去力扣看看官方题解, 然后再看本文内容).

关于本专栏所有题目的目录链接, 刷算法题目的顺序/注意点/技巧, 以及思维导图源文件问题请点击此链接.

想进大厂, 刷算法是必不可少的, 欢迎和博主一起打卡刷力扣算法, 博主同步更新了算法视频讲解和其他文章/导图讲解, 更易于理解, 欢迎来看!

关注博主获得题解更新的最新消息!!!

文章目录

0.导图整理
1.两个状态的动态规划
1.1 两个状态的思想
1.2 递推公式的变化
1.3 no[i-2]是否为最大利润
1.4 初始化的不同
1.5 空间优化的难点

2.三个状态的动态规划
源码
Python:
java:

题目链接: https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-with-cooldown/solution/si-wei-dao-tu-zheng-li-liang-chong-dpshu-4vu3/

0.导图整理

1.两个状态的动态规划

1.1 两个状态的思想

本题就是在股票II买卖多次的基础上增加了冷冻期的条件, dp数组定义过程基本相似, 大家可以先看完上面的题解, 再来看本题题解.

大家在看其他题解的时候, 肯定大部分都是三个状态的动态规划解法, 这种解法也确实符合一般的思路, 毕竟前面几题我们大多都定义的两个状态: 持有have[i]和不持有no[i]股票, 现在多了个冷冻期的附加条件, 那自然想到再多加一个状态单独表示冷冻期的情况. 但总感觉这样的三个状态和前面几题就不统一了, 那么能不能还用两个状态解决此题呢?

我们首先观察下冷冻期的概念, 它是在股票卖出之后才会出现的情况, 也就是说处于冷冻期时一定是不持有股票的, 所以可以将它合并到状态no[i]中, 这样就将三个状态成功转化为两个状态了.

1.2 递推公式的变化

状态定义完了, 就是递推公式的推导了, 根据之前的经验, 递推公式由四种情况组合而成, 而这四种情况中和冷冻期有关的就只有第i天买入股票的情况了, 其他的三种状态都和冷冻期关系不大, 并未受太大影响, 递推公式也没什么变化.

下面我们就来着重分析这种情况, 当第i天买入股票时, 那第i-1天必定是不持有股票且不能是冷冻期, 而只用no[i-1]这个状态并不能区别出是否为冷冻期, 所以这里我们采用no[i-2]这个状态.

现在我们来说明这个状态的合理性: no[i-2]由两种情况组成:

如果no[i-2]是在第i-2天卖出股票, 那第i-1天就是冷冻期, 那第i天就解冻了.
如果no[i-2]是延续了前一天i-3天不持有股票的状态, 那么在第i-1天就不会有股票被卖出, 那么第i天也不会是冷冻期.

综合上述两种情况, 无论no[i-2]是由哪个情况转移而来, 第i天都不是冷冻期.

1.3 no[i-2]是否为最大利润

上述说明了使用了no[i-2]的合理性, 那么就剩最后一个问题了, 我们跳过了no[i-1]这个状态, 那么no[i-2]是否就是当前的最大利润呢?

这里还是用上述no[i-2]的两种情况来说明:

如果no[i-2]是在第i-2天卖出股票, 那第i-1天就是冷冻期, 利润不会发生变化.
如果no[i-2]是延续了前一天i-3天不持有股票的状态, 那么在i-1天可能延续i-2天不持有股票的状态, 利润仍然不变, 也可能在i-1天买入股票, 首先利润就变小了, 其次状态也变为have[i-1], 不是我们需要的no状态.

综合两种情况来看, no[i-2]就是当前的最大利润, 这点理解之后, 递推公式就没什么难度了.

1.4 初始化的不同

之前都是初始化了have[0]和no[0]两个状态就可以了, 本题由于使用到了no[i-2]这个状态, 在i=1时是不合法的, 所以本题还要初始化have[1]和no[1]两个状态, 根据递推公式就可以了, 也没什么难度, 就是麻烦了一点.

1.5 空间优化的难点

本题在空间优化上是有点难度的, 因为我们需要用到no[i-2]的状态, 所以必须用变量同时存储no[i-2]和no[i-1]的状态, 变量记录的位置要确定好, 具体实现可以看最后的代码.

2.三个状态的动态规划

上文提到了最常规的思想就是在两个状态的基础上再新增一个状态用来表示冷冻期, 当然no[i]的含义也发生了一点的变化

have[i] 表示第i天持有股票所得最多现金
no[i] 表示第i天不持有股票且不处于冷冻期所得最多现金
cold[i] 表示第i天不持有股票且处于冷冻期所得最多现金

定义了这三个状态之后, 根据之前的经验, 状态转移方程也不难写出, 如下:

这里的have[i]没有变化, cold[i]也很容易写出, 唯一变化较大的就是no[i]了, 可能有人会感觉当天卖出股票也是满足的, 因为到第二天才会是冷冻期.

官方题解的解释是f[i]表示第 i 天结束之后的「累计最大收益」, 这种定义方式确实解决了这个问题, 但理解起来有点麻烦, 感觉绕了一下, 而且这种定义方式和之前的股票问题就有了差距, 不方便将它们整合起来, 所以我的理解是 只要卖出了股票就处于冷冻期, 不一定非要等到第二天, 这样来理解, 问题就容易想清楚了.

源码

Python:

## 两个状态
## 未进行空间优化
class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        n = len(prices)
        if n <= 1 :
            return 0
        
        have = [0] * n
        no = [0] * n
        have[0] = - prices[0]
        no[0] = 0     
        have[1] = max(have[0], -prices[1])
        no[1] = max(no[0], have[0] + prices[1])
        for i in range(2, n) :
            no[i] = max(no[i - 1], have[i - 1] + prices[i])
            have[i] = max(have[i - 1], no[i - 2] - prices[i])
        
        return no[n - 1]

## 空间优化
class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        n = len(prices)
        if n <= 1 :
            return 0
        
        have = - prices[0] # 对have[0]初始化
        no = 0     
        temp = no # 当i=2时, 记录下第一个no[i-2]
        have = max(have, -prices[1]) # 对have[1]初始化
        no = max(no, have + prices[1])
        for i in range(2, n) :
            no_i2 = temp # 记录下no[i-2]
            temp = no    # 记录下no[i-1]
            no = max(no, have + prices[i])
            have = max(have, no_i2 - prices[i])
        return no

## 三个状态
## 未进行空间优化
class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        length = len(prices)
        if len == 0:
            return 0
        have = [0] * length  # 表示第i天持有股票所得最多现金
        no = [0] * length    # 表示第i天不持有股票且不在冷冻期所得最多现金
        cold = [0] * length  # 表示第i天不持有股票且在冷冻期所得最多现金
        have[0] = -prices[0] # 此时的持有股票就一定是买入股票了
        no[0] = 0            # 不持有股票那么现金就是0
        cold[0] = 0
        for i in range(1, length):
            have[i] = max(have[i-1], no[i-1] - prices[i]); 
            no[i] = max(no[i-1], cold[i-1]);
            cold[i] = have[i-1] + prices[i];
        return max(cold[-1], no[-1])

## 空间优化
class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        length = len(prices)
        if len == 0:
            return 0

        have = -prices[0] # 此时的持有股票就一定是买入股票了
        no = 0            # 不持有股票那么现金就是0
        cold = 0
        for i in range(1, length):
            have = max(have, no - prices[i]); 
            no = max(no, cold);
            cold = have + prices[i];
        return max(cold, no)

java:

// 两个状态
// 未进行空间优化
class Solution {
    public int maxProfit(int[] prices) {
        int n = prices.length;
        if (n <= 1) {
            return 0;
        }
        int[] have = new int[n];
        int[] no = new int[n];
        have[0] = - prices[0];
        no[0] = 0;     
        have[1] = Math.max(have[0], -prices[1]);
        no[1] = Math.max(no[0], have[0] + prices[1]);
        for (int i = 2; i < n; i++) {
            no[i] = Math.max(no[i - 1], have[i - 1] + prices[i]);
            have[i] = Math.max(have[i - 1], no[i - 2] - prices[i]);
        }
        return no[n - 1];
    }
}

// 三个状态
// 未进行空间优化
public class Solution {
    public int maxProfit(int[] prices) {
        int len = prices.length;
        if (len < 2) {
            return 0;
        }
        int[] have = new int[len];  // 表示第i天持有股票所得最多现金
        int[] no = new int[len];    // 表示第i天不持有股票且不在冷冻期所得最多现金
        int[] cold = new int[len];  // 表示第i天不持有股票且在冷冻期所得最多现金
        have[0] = -prices[0]; // 此时的持有股票就一定是买入股票了
        no[0] = 0;            // 不持有股票那么现金就是0
        cold[0] = 0;


        for (int i = 1; i < len; i++) {
            have[i] = Math.max(have[i-1], no[i-1] - prices[i]); 
            no[i] = Math.max(no[i-1], cold[i-1]);
            cold[i] = have[i-1] + prices[i];
        }
        return Math.max(cold[len - 1], no[len - 1]);
    }
}