算法通关村第十九关：青铜-动态规划是怎么回事

青铜挑战-动态规划是怎么回事

动态规划（简称DP，Dynamic Programming）：最热门、最重要的算法之一。面试中大量出现，整体偏难。

1. 热身：重复计算和记忆化搜索（如何说一万次"我爱你"）

举例：看谁说更多的我爱你

class FibonacciTest:
    def __init__(self):
        self.count = 0

    def main(self, n):
        self.fibonacci(n)
        print(f"n: {n}, count: {self.count}")

    def fibonacci(self, n):
        print("我爱你")
        self.count += 1
        if n == 0:
            return 1
        elif n == 1 or n == 2:
            return n
        else:
            return self.fibonacci(n - 1) + self.fibonacci(n - 2)


if __name__ == '__main__':
    for i in range(32):
        FibonacciTest().main(i)

斐波那契数列，重复打印 “我爱你”
n=20时，count=13529；n=30时，count=1664079

n=30时，count高达160多万，因为里面存在大量的重复计算，数越大，重复越多。

n=8时，结构如下
在这里插入图片描述

计算 f(8) 时，f(6)、f(5)等需要重复计算，这就是重叠子问题

优化：
主要问题是很多数据到会频繁重复计算
将计算的结果保存到一个一维数组中，arr[n] = f(n)
执行的时候如果某个位置已经被计算出来就更新对应位置的数组值，下次计算的时候可直接读取

记录化搜索
在执行递归之前先查数组看是否被计算过，如果重复计算了，就直接读取，这就叫记忆化搜索

class FibonacciTest:
    def __init__(self):
        self.count = 0
        self.arr = []

    def main(self, n):
        self.arr = [-1] * (n + 1)
        self.fibonacci(n)
        print(f"n: {n}, count: {self.count}")

    def find_in_arr(self, n):
        return self.arr[n] if 0 <= n < len(self.arr) else -1

    def fibonacci(self, n):
        # print("我爱你")
        self.count += 1
        if n == 1 or n == 2:
            self.arr[n] = n
            return n
        elif self.arr[n] != -1:
            return self.arr[n]
        else:
            self.arr[n] = self.fibonacci(n - 1) + self.fibonacci(n - 2)
            return self.arr[n]


if __name__ == '__main__':
    FibonacciTest().main(20)

n=20时，count=37；n=30时，count=57。
递归计算大为减少

2. 路径连环炮

本部分通过多个路径相关的问题来解释和分析DP

2.1 第一炮：基本问题-统计路径总数

LeetCode62
https://leetcode.cn/problems/unique-paths/

思路分析

本题是经典的递归问题

从起点开始的每一个位置，要么向右，要么向下
向右和向下都将导致剩下的区间减少一列或者一行
每个区间都可以继续以当前点为起点继续上述操作，所以这是一个递归的过程

在这里插入图片描述

分析3x2矩阵
在这里插入图片描述

分析3x3矩阵
在这里插入图片描述

分析可以看出，对于一个m x n的矩阵，求路径总数的方法 search(m, n) = search(m-1, n) + search(m, n-1)

对于上述过程，也可以用二叉树表示出来，以3x3矩阵为例
在这里插入图片描述

总的路径就是叶子结点数，图中有6个，这与二叉树的递归遍历本质上是一样的

代码实现

class Solution:
    def uniquePaths(self, m: int, n: int) -> int:
        if m == 1 or n == 1:
            return 1
        return self.uniquePaths(m - 1, n) + self.uniquePaths(m, n - 1)


if __name__ == '__main__':
    print(Solution().uniquePaths(3, 2))

注：功能没有问题，LeetCode上提交，判断超时了

2.2 第二炮：使用二维数组优化递归

在第一炮中，存在重复计算的问题，可以结合二维数组实现记忆化搜索

在这里插入图片描述

从数可以看到，在递归的过程中，存在重复计算的情况
例如 {1,1} 出现了两次，如果m=n，{1,0} 和 {0,1}的后续计算也是一样的
从二维数组的角度，例如在位置(1,1)处，不管是从(0,1)还是(1,0)到来，接下来都会产生2种走法，因此不必每次都重新遍历

在这里插入图片描述

可以采取一个二维数组来进行记忆化搜索

在这里插入图片描述

每个格子的数字：表示从起点开始到达当前位置有几种方式

第1行和第1列都是1
其他格子的值是其左侧和上侧格子数字之和 f[i][j] = f[i-1][j] + f[i][j-1]

在这里插入图片描述

代码实现

class Solution:
    def uniquePaths(self, m: int, n: int) -> int:
        arr = [[-1] * n for _ in range(m)]
        for i in range(m):
            for j in range(n):
                if i == 0 or j == 0:
                    arr[i][j] = 1
                else:
                    arr[i][j] = arr[i - 1][j] + arr[i][j - 1]
        return arr[m - 1][n - 1]

2.3 第三炮：滚动数组-用一维数组代替二维数组

上面的缓存空间使用的二维数组，占空间太大；可以使用滚动数组来优化此问题

滚动数组

在这里插入图片描述

第1行和第1列都是1
每个位置都是其左侧和上方的格子之和

以上可以简化为一个大小为n的一维数组来解决

遍历数组，将数组所有元素赋值为1，[1,1,1,1,1]
再次遍历数组，除了第1个，后面每个位置值=原始值+前一个位置值，[1,2,3,4,5]
再次遍历数组，除了第1个，后面每个位置值=原始值+前一个位置值，[1,3,6,10,15]
继续循环，循环m次
此处3*5，m=3，循环3次，输出最后的15为结果

上面这几个一维数组拼接起来就是原先的二维数组

这种反复更新数组的策略就是滚动数组，计算公式 dp[j] = dp[j] + dp[j-1]

代码实现

class Solution:
    def uniquePaths(self, m: int, n: int) -> int:
        arr = [1] * n
        for i in range(1, m):
            for j in range(1, n):
                arr[j] = arr[j] + arr[j - 1]
        return arr[-1]

总结

本题涵盖了DP里的多个方面，比如重复子问题、记忆化搜索、滚动数组等等
这就是最简单的动态规划了，只不过我们这里的规划是 dp[j] = dp[j] + dp[j-1]，不用进行复杂的比较和计算

这个题目非常重要，对后面理解递归、动态规划等算法有非常大的作用

2.4 第四炮：题目拓展-最小路径和

上面的题目（LeetCode62）还有个重要的问题体现的不明显：最优子结构

LeetCode64
https://leetcode.cn/problems/minimum-path-sum/

思路分析

这道题目就是在上面题目的基础上，增加了路径成本的概念。

在这里插入图片描述

由于题目限定只能往下或者往右，可以按照当前位置可由哪些位置移动过来进行分析

通过往下移动过来，f[i][j] = f[i-1][j] + grid[i][j]
通过往右移动过来，f[i][j] = f[i][j-1] + grid[i][j]
通过往下或者往右移动过来，f[i][j] = min(f[i-1][j], f[i][j-1]) + grid[i][j]

二维数组的更新过程如下
在这里插入图片描述

引入新概念

状态与状态转移方程
状态：就是下面表格更新到最后的二维数组（？不太理解，简单的就是状态转移方程计算出来的值）

状态转移方程：通过前面格子状态计算后面格子状态的公式就叫状态转移方程

数组表达：
f[i][j] 从(0,0)开始到达位置(i,j)的最小路径成本总和，f[m-1][n-1]就是我们最终的答案

起始状态 f[0][0] = grid[0][0]

状态转移方程
f[i][j] = min(f[i-1][j], f[i][j-1]) + grid[i][j]

在这里插入图片描述

注：确定状态转移方程就是要找递推关系，通常我们会从分析首尾两端的变化规律入手

代码实现

class Solution:
    def minPathSum(self, grid: List[List[int]]) -> int:
        m, n = len(grid), len(grid[0])
        arr = [[0] * n for _ in range(m)]
        for i in range(m):
            for j in range(n):
                if i == 0 and j == 0:
                    arr[i][j] = grid[i][j]
                elif i == 0:
                    arr[i][j] = arr[i][j - 1] + grid[i][j]
                elif j == 0:
                    arr[i][j] = arr[i - 1][j] + grid[i][j]
                else:
                    arr[i][j] = min(arr[i][j - 1], arr[i - 1][j]) + grid[i][j]
        return arr[m - 1][n - 1]

class Solution:
    def minPathSum(self, grid: List[List[int]]) -> int:
        m, n = len(grid), len(grid[0])
        for i in range(m):
            for j in range(n):
                if i == 0 and j == 0:
                    continue
                elif i == 0:
                    grid[i][j] = grid[i][j - 1] + grid[i][j]
                elif j == 0:
                    grid[i][j] = grid[i - 1][j] + grid[i][j]
                else:
                    grid[i][j] = min(grid[i][j - 1], grid[i - 1][j]) + grid[i][j]
        return grid[-1][-1]

class Solution:
    def minPathSum(self, grid: List[List[int]]) -> int:
        m, n = len(grid), len(grid[0])
        arr = [[0] * n for _ in range(m)]
        for i in range(m):
            for j in range(n):
                if i == 0 and j == 0:
                    arr[i][j] = grid[i][j]
                else:
                    top = arr[i - 1][j] + grid[i][j] if i - 1 >= 0 else float('inf')
                    left = arr[i][j - 1] + grid[i][j] if j - 1 >= 0 else float('inf')
                    arr[i][j] = min(top, left)
        return arr[-1][-1]

2.5 第五炮：题目拓展-三角形最小路径和

LeetCode120
https://leetcode.cn/problems/triangle/description/

本题就是LeetCode64最小路径和的简单变换

思路分析

处理过程如下:
为了方便处理，我们可以先处理第1列和对角线

在这里插入图片描述

引入新概念 无后效性

无后效性：
我们转移某个状态需要用到某个值，但是并不关心该值是如何而来的
或者说，当前某个状态确定后，之后的状态转移与之前的决策无关

确定一道题目是否可以用 DP 解决，要从有无后效性进行分析。有后效性，不能用DP；无后效性，可以用DP。

本题中

路径从上到小，最后一个点必然落在最后一行
最后一行某个位置的值，只能从上一行的某一个位置或者某两个位置之一转移而来
我们只关注前一位的累加值是多少，而不关心这个累加值结果是由什么路径而来，满足无后效性

找递推关系，确定状态

f[i][j] 代表到达某个点的最小路径和，min(f[n-1][i]) 就是答案，最后一行的每列的路径和的最小值

第i行有i+1个数组（i从0开始）
第一列位置上的数(j=0)，只能从上方转移而来
最后一列位置上的数(j=i)，只能从左上方转移而来
其他位置上的数(0<j<i)，可以从上方或者左上方转移而来

代码实现

class Solution:
    def minimumTotal(self, triangle: List[List[int]]) -> int:
        m = len(triangle)
        n = len(triangle[-1])
        arr = [[0] * n for _ in range(m)]
        for i in range(m):
            for j in range(n):
                if j > i:
                    continue
                elif j == 0:
                    arr[i][j] = arr[i - 1][j] + triangle[i][j]
                elif j == i:
                    arr[i][j] = arr[i - 1][j - 1] + triangle[i][j]
                else:
                    arr[i][j] = min(arr[i - 1][j], arr[i - 1][j - 1]) + triangle[i][j]
        return min(arr[-1])

if __name__ == '__main__':
    print(Solution().minimumTotal([[2], [3, 4], [6, 5, 7], [4, 1, 8, 3]]))  # 11

代码优化

class Solution:
    def minimumTotal(self, triangle: List[List[int]]) -> int:
        m = len(triangle)
        arr = [[0] * m for _ in range(m)]
        arr[0][0] = triangle[0][0]

        for i in range(1, m):
            arr[i][0] = arr[i - 1][0] + triangle[i][0]
            for j in range(1, i):
                arr[i][j] = min(arr[i - 1][j], arr[i - 1][j - 1]) + triangle[i][j]
            arr[i][i] = arr[i - 1][i - 1] + triangle[i][i]

        return min(arr[m - 1])

题目拓展

类似题目还有 LeetCode931 下降路径最小和和 LeetCode1289 下降路径最小和II

3，. 理解动态规划

3.1 动态规划(DP)能解决哪类问题

直观上，DP一般让找最值。例如最长公共子序列等。
关键：DP问题的子问题不是相互独立的，如果递归直接分解会导致重复计算指数级增长。
DP最大的价值：消除冗余，加速计算

DP要满足无后效性

对于某个状态，可以只关注状态的值，而不需要关注状态是如何转移过来，可以考虑用 DP 解决

例如：
上面路径问题，从左上角走到右下角，两个问题：

求有多少种走法
输出所有的走法

分析：

动态规划是无后效性的，只记录数量，不管怎么来的。A是DP问题，B不能用DP
回溯可以记录所有的路径，B是个回溯的问题

回溯与DP的比较

回溯：能解决，但是解决效率不高
DP：计算效率高，但是不能找到满足要求的路径

如何区分：
DP只关心当前结果是什么，怎么来的就不管了，所以动态规划无法获得完整的路径
回溯能够获得一条甚至所有满足要求的完整路径

DP的基本思想：

将待求解问题分解成若干个子问题，先求子问题，在从这些子问题中得到原问题的解。

注：既然要找“最”值，必然要做的就是穷举来找所有的可能，然后选择“最”的那个，这就是为什么在DP代码中大量判断逻辑都会被套上min()或者max()

既然穷举，那为啥还要有 DP 的概念？

因为穷举过程中存在大量重复计算，效率低下，我们要使用记忆化搜索等方式来消除不必要的计算
所谓记忆化搜索就是将已经计算好的结果先存在数组里，后面直接读就不再重复计算了

既然记忆化能解决问题，为啥DP这么难？

因为DP问题一定具备“最优子结构”，这样才能让记忆时得到准确的结果
什么是最优子结构，还是要等后面具体问题再看

状态转移方程

有了最优子结构之后，还要写出正确的状态转移方程，也就是递归关系，才能正确的穷举
在DP里，大部分递推都可以通过数组实现，因此看起来代码结构一般是如下所示的for循环，这就是DP代码的基本模板

DP代码的基本模板

// 初始化base case，也就是初始化刚开始的几种场景，有几种枚举几种
dp[0][0][...] = base case

// 进行状态转移
for 状态1 in 状态1的所有值
    for 状态2 in 状态2的所有值
        for ...
            dp[状态1][状态2][...] = 求最值max(选择1, 选择2, ...)

我们一般写状态规划只有一两层，不会太深，代码看起来特别简洁

动态规划的常见类型

常见类型比较多，从形式上看，有坐标型、序列型、划分型、区间型、背包型、博弈型等等
解题基本思路是一致的

一般来说，DP题目有以下三种基本的类型

计数相关
有多少方式走到右下角，有多少种方式选出K个数使得***等
不关心具体路径是什么
求最大最小值，最多最少等
例如最大数字和、最长上升子序列长度、最长公共子序列、最长回文序列等
求存在性
例如取石子游戏，先手是否必胜，能不能选出K个数使得***等

但是不管哪一种，解决问题的模板是类似的，都是：

第一步：确定状态和子问题，也就是枚举出某个位置所有的可能性
对于DP，大部分题目分析最后一步更容易一些得到递推关系，同时将问题转换为子问题
第二步：确定状态转移方程，也就是数组要存储什么内容
很多时候状态确定之后，状态转移方程也就确定了，我们可以将第一二部作为一个步骤
第三步：确定初始条件和边界情况
注意细心，尽力考虑周全
第四步：按照从大到小的顺序计算：f[0] f[1] f[2]
虽然我们计算是从f[0]开始，但是对于大部分DP问题，先分析最后一个往往更有利于寻找状态表达式
因此我们后面的问题基本都是从右向左找递归，从左向右来计算

以上是我们分析DP问题的核心模板

总结