❤️思维导图整理大厂面试高频数组20: 股票问题IV的dp数组构建和几个重要注意点❤️

Posted 2022-11-28 孤柒「一起学计算机」

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了❤️思维导图整理大厂面试高频数组20: 股票问题IV的dp数组构建和几个重要注意点❤️相关的知识，希望对你有一定的参考价值。

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

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

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

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

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

文章目录

0.导图整理
1.dp数组的构建
2.确定递推公式
3.dp数组初始化
4.最终返回结果
5.几个重要的注意点
5.1 k的正序和倒序
5.2 k的范围
5.3 have数组的维数
5.4 Integer.MIN_VALUE / 2
5.5 j的循环

源码
Python:
java:

题目链接: https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-iv/solution/si-wei-dao-tu-zheng-li-dpshu-zu-gou-jian-e97c/

0.导图整理

1.dp数组的构建

本题在形式上似乎是股票III最多买卖两次的进阶版, 但其实本题是所有股票问题的通解问题, 其他的股票问题只是在k的取值上有所不同, 但它们的思想都可以用本题的思想来解决, 之后也会单独写一篇文章来总结所有的股票问题.

对于dp数组的定义, 我们首先要确定一共有多少个状态, 通过前面几道题目的训练, 我们可以确定的状态有: 当天的天数i, 当天是否持有股票. 但本题的特殊之处在于: 我们必须还要确定当前进行了几笔交易j, 因为前面的几道题中, k要么是1, 要么是正无穷, 所以我们也不需要将它单独作为一个状态, 但本题就不同了, k可以取任意的值, 所以它也必须作为一个状态.

所以本题必须用3个状态才能完整表示dp数组, 也就是三维dp数组, 按照我们之前说过的方法, 可以通过命名来优化一个状态, 也就是have表示持有状态, no表示不持有状态(我觉得这样的命名比官方的buy, sell更明确), 所以最终的dp数组就是二维dp数组:

have[i][j]表示进行恰好 j 笔交易, 并且当前手上持有一支股票, 这种情况下的最大利润.
no[i][j] 表示进行恰好 j 笔交易, 并且当前手上不持有股票, 这种情况下的最大利润.

这里我们必须还要明确一个概念: k何时进行变化. 这点很重要, 直接就导致之后递推公式的不同. 官方题解是默认一买一卖才算完整交易一次, 买入不算交易, 卖出才算一次交易, 所以只有卖出时k变化. 当然也有人定义的是买入时k变化, 这种就会产生不同的递推公式, 但都是正确的.

2.确定递推公式

定义出了dp数组之后, 按照前面几题的经验, 递推公式就没太大难度了, 还是每种状态都由两种情况组合而来, 最终取最大值:

根据上面我们定义的k何时变化, 体现在递推公式中就是在推导no[i][j]的第二种情况时用到的have[i-1][j-1], 因为卖出股票时k会变化, 所以上一个持有股票的状态就是k-1了. 这点一定要注意, 它不止在递推公式中很重要, 也在之后的空间优化时很重要!

3.dp数组初始化

本题的初始化过程还是有点复杂的, 但是并不难理解, 这里就不多解释了:

4.最终返回结果

由于在所有的 n 天结束后, 手上不持有股票对应的最大利润一定是严格大于手上持有股票对应的最大利润的, 然而完成的交易数并不是越多越好（例如数组prices 单调递减,我们不进行任何交易才是最优的）, 因此最终的答案即为no[n−1][0…k]中的最大值.

5.几个重要的注意点

5.1 k的正序和倒序

本题为了避免状态压缩造成的数据覆盖, 应该采用k倒序才对. 它的解释如下: 最后一行计算no[j](no[i][j])时所用的have[j-1], 本应为have[i-1][j-1]。然而由于采用了状态压缩, i不变, j的前一个循环刚刚计算了have[i][j-1]赋值给了have[j-1], 所以have[j-1]实际为have[i][j-1], 与转移方程产生了偏差.

这是需要采用倒序的原因, 但是本题采用正序也是可以得到相同的结果的, 官方对此也进行了解释, 当然也有人专门写了文章进行推理说明, 导图中也放了相应的链接, 感兴趣的可以去看看, 过程还是挺复杂的.

但是从实际来说, 将k进行倒序, 在代码上是非常容易实现的操作, 只有在j的遍历范围上有一点改动, 其他是完全一样的, 所以我们还是尽可能用倒序遍历保证安全性, 毕竟本题没有影响, 不代表其他动态规划的题目也没有影响, 而且这么容易实现的操作, 根本没什么成本代价可言!

5.2 k的范围

如果交易次数大于n/2, 必然存在有一天交易了两次, 然而这是毫无意义的, 因为 n 天最多只能进行⌊n/2⌋ 笔交易, 其中⌊x⌋ 表示对x向下取整。因此我们可以将 k 对⌊n/2⌋ 取较小值之后再进行动态规划.

5.3 have数组的维数

k+1维是没问题的, 如果维数只有k, 就表示不了交易0次了, 要是数组一直是递减的, 一交易就是亏损.

5.4 Integer.MIN_VALUE / 2

在这是在java中可能遇到的问题, 因为在之后的操作中可能会减去prices[i], 这样就可能导致Integer.MIN_VALUE越界翻转, 所以这里进行了除以2的操作, 在python中是不用担心这个问题的.

5.5 j的循环

no[i][j]的状态转移方程中包含have[i−1][j−1], 在j=0 时其表示不合法的状态, 因此在 j=0 时, 我们无需对 no[i][j] 进行转移, 让其保持值为 0 即可, 所以在j=0时, 我们需要单独对have[i][0]进行处理.

源码

Python:

## 未进行空间优化
class Solution:
    def maxProfit(self, k: int, prices: List[int]) -> int:
        if not prices:
            return 0


        n = len(prices)
        k = min(k, n // 2)  # k最大为总天数的一半
        have = [[0] * (k + 1) for _ in range(n)]
        no = [[0] * (k + 1) for _ in range(n)]


        have[0][0], no[0][0] = -prices[0], 0
        for i in range(1, k + 1): # 不合法状态
            have[0][i] = no[0][i] = float("-inf")


        for i in range(1, n): # j=0时, no[i][0]不合法
            have[i][0] = max(have[i - 1][0], no[i - 1][0] - prices[i])
            for j in range(1, k + 1):
                have[i][j] = max(have[i - 1][j], no[i - 1][j] - prices[i])
                no[i][j] = max(no[i - 1][j], have[i - 1][j - 1] + prices[i]);  


        return max(no[n - 1])

## 进行空间优化
class Solution:
    def maxProfit(self, k: int, prices: List[int]) -> int:
        if not prices:
            return 0


        n = len(prices)
        k = min(k, n // 2)  # k最大为总天数的一半
        have = [0] * (k + 1)
        no = [0] * (k + 1)


        have[0], no[0] = -prices[0], 0
        for i in range(1, k + 1): # 不合法状态
            have[i] = no[i] = float("-inf")


        for i in range(1, n): # j=0时, no[0]不合法
            have[0] = max(have[0], no[0] - prices[i])
            for j in range(k, 0, -1): # 优化空间, k倒序
                have[j] = max(have[j], no[j] - prices[i])
                no[j] = max(no[j], have[j - 1] + prices[i]); 


        return max(no)

java:

// 未进行空间优化
class Solution 
    public int maxProfit(int k, int[] prices) 
        if (prices.length == 0) 
            return 0;
        


        int n = prices.length;
        k = Math.min(k, n / 2);  // k最大为总天数的一半
        int[][] have = new int[n][k + 1];
        int[][] no = new int[n][k + 1];


        have[0][0] = -prices[0];
        no[0][0] = 0;
        for (int i = 1; i <= k; ++i)  // 不合法状态,/2防止越界翻转
            have[0][i] = no[0][i] = Integer.MIN_VALUE / 2;
        


        for (int i = 1; i < n; ++i)  // j=0时, no[i][0]不合法
            have[i][0] = Math.max(have[i - 1][0], no[i - 1][0] - prices[i]);
            for (int j = 1; j <= k; ++j) 
                have[i][j] = Math.max(have[i - 1][j], no[i - 1][j] - prices[i]);
                no[i][j] = Math.max(no[i - 1][j], have[i - 1][j - 1] + prices[i]);   
            
        


        return Arrays.stream(no[n - 1]).max().getAsInt();