动态规划:斐波那契数,爬楼梯，不同路径，整数拆分，不同二叉树

基础

很多重叠子问题 ，动态规划中每一个状态一定是由上一个状态推导出来的，这一点就区分于贪心，贪心没有状态推导，而是从局部直接选最优的

1确定dp数组（dp table）以及下标的含义
2确定递推公式
3dp数组如何初始化
4确定遍历顺序
5举例推导dp数组

假设需要在一堆数内求这个不冲突的最大价值。vi+OPT(pre(i)) pre(i)表示如果选了i那么在那之前只能选prev(i)

选不相邻的数的最大和

在数字中选择是否能找到和为s的组合

递归
动态规划
dp[i][j]表示的是subset(arr[i]，s)

斐波那契数列

class Solution:
    def fib(self, n: int) -> int:
        if n < 2:
            return n
        dp = [0] * (n + 1)
        dp[0] = 0
        dp[1] = 1
        print(dp)
        for i in range(2,n + 1):
            dp[i] = dp[i - 1] + dp[i - 2]
        return dp[n]
    

只维持两个数

class Solution:
    def fib(self, n: int) -> int:
        if n < 2:
            return n
        dp = [0,1]
        for i in range(2,n + 1):
            temp = dp[0] + dp[1]
            dp[0] = dp[1]
            dp[1] = temp
        return dp[1]
    

70. 爬楼梯

确定dp数组以及下标的含义
dp[i]： 爬到第i层楼梯，有dp[i]种方法

确定递推公式
如果可以推出dp[i]呢？

从dp[i]的定义可以看出，dp[i] 可以有两个方向推出来。

首先是dp[i - 1]，上i-1层楼梯，有dp[i - 1]种方法，那么再一步跳一个台阶不就是dp[i]了么。

还有就是dp[i - 2]，上i-2层楼梯，有dp[i - 2]种方法，那么再一步跳两个台阶不就是dp[i]了么。

那么dp[i]就是 dp[i - 1]与dp[i - 2]之和！

所以dp[i] = dp[i - 1] + dp[i - 2] 。

在推导dp[i]的时候，一定要时刻想着dp[i]的定义，否则容易跑偏。

这体现出确定dp数组以及下标的含义的重要性！

 class Solution:
    def climbStairs(self, n: int) -> int:
        if n < 2 :return 1 # 防止n<2时候 dp[2]越界
        dp = [0] * (n + 1)
        dp[1] = 1
        dp[2] = 2
        for i in range(3,n + 1):
            dp[i] = dp[i - 1] + dp[i - 2]
        return dp[n]

746. 使用最小花费爬楼梯

1确定dp数组以及下标的含义
dp[i]的定义：到达第i个台阶所花费的最少体力为dp[i]。
2递推公式
两个途径得到dp[i]，一个是dp[i-1] 一个是dp[i-2]。
站在第i阶时向上爬，肯定要花费cost[i]
dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i];每当你爬上一个阶梯你都要花费对应的体力值
注意： 最后一步（到达顶点不花费）可以理解为不用花费，所以取倒数【第一步，第二步】的最少值
3初始化 初始化dp[0]和dp[1]
4确定遍历顺序
5

class Solution:
    def minCostClimbingStairs(self, cost: List[int]) -> int:
        dp = [0] * (len(cost))
        dp[0] = cost[0]
        dp[1] = cost[1]
        for i in range(2,len(cost)):
            dp[i]  =  min(dp[i - 1], dp[i - 2]) + cost[i]
        return min(dp[-1],dp[-2])

62.不同路径

法一 深搜
机器人每次只能向下或者向右移动一步，那么其实机器人走过的路径可以抽象为一棵二叉树，而叶子节点就是终点！
1.1边界
1.2 return 1 的情况
1.3 return dfs(i + 1, j, m, n) + dfs(i, j + 1, m, n);

法二 动态规划

1确定dp数组（dp table）以及下标的含义
dp[i][j] ：表示从（0 ，0）出发，到(i, j) 有dp[i][j]条不同的路径。

2确定递推公式
想要求dp[i][j]，只能有两个方向来推导出来，即dp[i - 1][j] 和 dp[i][j - 1]。

此时在回顾一下 dp[i - 1][j] 表示啥，是从(0, 0)的位置到(i - 1, j)有几条路径，dp[i][j - 1]同理。

那么很自然，dp[i][j] = dp[i - 1][j] + dp[i][j - 1]，因为dp[i][j]只有这两个方向过来。

3 dp数组的初始化
如何初始化呢，首先dp[i][0]一定都是1，因为从(0, 0)的位置到(i, 0)的路径只有一条，那么dp[0][j]也同理。

4 确定遍历顺序
这里要看一下递归公式dp[i][j] = dp[i - 1][j] + dp[i][j - 1]，dp[i][j]都是从其上方和左方推导而来，那么从左到右一层一层遍历就可以了。

这样就可以保证推导dp[i][j]的时候，dp[i - 1][j] 和 dp[i][j - 1]一定是有数值的。

5举例推导dp数组
如图所示：

class Solution:
    def uniquePaths(self, m: int, n: int) -> int:
        # m行n列 等价
        dp = [[1]*n]*m
        #dp = [[1 for i in range(n)] for j in range(m)]
        print(dp)
        # d初始化 dp[i][0]=1 dp[0][i]=1 初始化横竖就可

        for i in range(1,m):
            for j in range(1,n):
                dp[i][j] = dp[i-1][j] + dp[i][j-1]
        return dp[-1][-1]

法三：
数论

class Solution:
    def uniquePaths(self, m: int, n: int) -> int:
        # 数论
        mother = 1
        son = 1
        count = m - 1
        temp = m + n - 2
        # 计算分子
        while count > 0:
            son = son * temp
            temp -= 1
            count -= 1
       
        # 计算分母
        for i in range(1,m):
            mother = mother * i
        print(mother)
        return son//mother

63. 不同路径 II

1 确定dp数组（dp table）以及下标的含义
dp[i][j] ：表示从（0 ，0）出发，到(i, j) 有dp[i][j]条不同的路径。

2确定递推公式
递推公式和62.不同路径一样，dp[i][j] = dp[i - 1][j] + dp[i][j - 1]。

但这里需要注意一点，因为有了障碍，(i, j)如果就是障碍的话应该就保持初始状态（初始状态为0）

所以代码为：

if (obstacleGrid[i][j] == 0) { // 当(i, j)没有障碍的时候，再推导dp[i][j]
    dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
}

3dp数组如何初始化
在62.不同路径 (opens new window)不同路径中我们给出如下的初始化：

因为从(0, 0)的位置到(i, 0)的路径只有一条，所以dp[i][0]一定为1，dp[0][j]也同理。

但如果(i, 0) 这条边有了障碍之后，障碍之后（包括障碍）都是走不到的位置了，所以障碍之后的dp[i][0]应该还是初始值0。

下标(0, j)的初始化情况同理。

一旦遇到obstacleGrid[i][0] == 1的情况就停止dp[i][0]的赋值1的操作，dp[0][j]同理 障碍之后的都走不通。

4确定遍历顺序
从递归公式dp[i][j] = dp[i - 1][j] + dp[i][j - 1] 中可以看出，一定是从左到右一层一层遍历，这样保证推导dp[i][j]的时候，dp[i - 1][j] 和 dp[i][j - 1]一定是有数值。

代码如下：

for (int i = 1; i < m; i++) {
    for (int j = 1; j < n; j++) {
        if (obstacleGrid[i][j] == 1) continue;
        dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
    }
}

5举例推导dp数组

class Solution:
    def uniquePathsWithObstacles(self, obstacleGrid: List[List[int]]) -> int:
        row = len(obstacleGrid)
        col = len(obstacleGrid[0])

        # dp = [[0]*col] * row
        # print(dp)
        dp = [[0 for _ in range(col)] for _ in range(row)]
        print(dp)
        # 判断起点是不是障碍
        if obstacleGrid[0][0] != 1:
            dp[0][0] = 1
        else:
            dp[0][0] = 0
            
        # 对起点判断
        if dp[0][0] == 0:return 0

        # 初始化dp 第一行第一列是dp[i][0] dp[0][i]是1
        # 如果遇到障碍 障碍之后的都是0 所以可以等于前面的数
        
        # 初始化第一行 固定行
        for i in range(1,col):
            if obstacleGrid[0][i] != 1:
                dp[0][i] = dp[0][i-1]
        # 初始化第一列 固定列
        for i in range(1,row):
            if obstacleGrid[i][0] != 1:
                dp[i][0] = dp[i-1][0]
       
        print(dp)

        for i in range(1,row):
            for j in range(1,col):
                # 不是障碍
                if obstacleGrid[i][j] != 1:
                    dp[i][j] = dp[i-1][j] + dp[i][j-1]
        
        return dp[-1][-1]

就是何时使用【回溯】，何时使用【动态规划】，用大白话说，就是：

首先看取值范围，递归回溯一维数组，100就是深度的极限了（何况本题是100²）
如果是求走迷宫的【路径】，必然是回溯；如果是走迷宫的【路径的条数】，必然是dp--------(这个竟然屡试不爽！！！！)

343. 整数拆分

1dp含义
dp[i]：分拆数字i，可以得到的最大乘积为dp[i]。
2递推公式
j * (i - j) 是单纯的把整数拆分为两个数相乘，而j * dp[i - j]是拆分成两个以及两个以上的个数相乘。定义dp[i - j] * dp[j] 也是默认将一个数强制拆成4份以及4份以上了。

dp[i] = max({dp[i], (i - j) * j, dp[i - j] * j});

3dp的初始化
严格从dp[i]的定义来说，dp[0] dp[1] 就不应该初始化，也就是没有意义的数值。
这里我只初始化dp[2] = 1，从dp[i]的定义来说，拆分数字2，得到的最大乘积是1

4确定遍历顺序
dp[i] 是依靠 dp[i - j]的状态，所以遍历i一定是从前向后遍历，先有dp[i - j]再有dp[i]。

枚举j的时候，是从1开始的。i是从3开始，这样dp[i - j]就是dp[2]正好可以通过我们初始化的数值求出来。

所以遍历顺序为：

5 举例推导dp数组

法一：数学
推导过程https://leetcode.cn/problems/integer-break/solution/343-zheng-shu-chai-fen-tan-xin-by-jyd/

法一 贪心 数学推导

class Solution:
    def integerBreak(self, n: int) -> int:
        if n <= 3: return n - 1
        a, b = n // 3, n % 3
        if b == 0: return int(math.pow(3, a))
        if b == 1: return int(math.pow(3, a - 1) * 4)
        return int(math.pow(3, a) * 2)

法二 动态规划

class Solution:
    def integerBreak(self, n: int) -> int:
        dp = [0] * (n + 1)
        dp[2] = 1
        for i in range(3, n + 1):
            # 假设对正整数 i 拆分出的第一个正整数是 j（1 <= j < i），则有以下两种方案：
            # 1) 将 i 拆分成 j 和 i−j 的和，且 i−j 不再拆分成多个正整数，此时的乘积是 j * (i-j)
            # 2) 将 i 拆分成 j 和 i−j 的和，且 i−j 继续拆分成多个正整数，此时的乘积是 j * dp[i-j]
            for j in range(1, i - 1):
                dp[i] = max(dp[i], max(j * (i - j), j * dp[i - j]))
        return dp[n]

96不同的二叉搜索树

看布局：



当3为头结点的时候，其左子树有两个节点，看这两个节点的布局，是不是和n为2的时候两棵树的布局也是一样的啊！

dp[3]，就是 元素1为头结点搜索树的数量 + 元素2为头结点搜索树的数量 + 元素3为头结点搜索树的数量

元素1为头结点搜索树的数量 = 右子树有2个元素的搜索树数量 * 左子树有0个元素的搜索树数量（1结点接的是两个结点的样子）

元素2为头结点搜索树的数量 = 右子树有1个元素的搜索树数量 * 左子树有1个元素的搜索树数量

元素3为头结点搜索树的数量 = 右子树有0个元素的搜索树数量 * 左子树有2个元素的搜索树数量
有2个元素的搜索树数量就是dp[2]。

有1个元素的搜索树数量就是dp[1]。

有0个元素的搜索树数量就是dp[0]。

所以dp[3] = dp[0] * dp[2] + dp[1] * dp[1] + dp[2] * dp[0]

1确定dp数组（dp table）以及下标的含义
dp[i] ： 1到i为节点组成的二叉搜索树的个数为dp[i]。
2确定递推公式
dp[i] += dp[以j为头结点左子树节点数量] * dp[以j为头结点右子树节点数量]
dp[i] += dp[j - 1] * dp[i - j]
3 dp数组如何初始化
从递归公式上来讲，dp[以j为头结点左子树节点数量] * dp[以j为头结点右子树节点数量] 中以j为头结点左子树节点数量为0，也需要dp[以j为头结点左子树节点数量] = 1， 否则乘法的结果就都变成0了。
所以初始化dp[0] = 1
4遍历顺序
那么遍历i里面每一个数作为头结点的状态，用j来遍历。
5 举例推导dp数组

class Solution:
    def numTrees(self, n: int) -> int:
        dp = [0]* (n+1)# 因为要累加和 所以dp[i]为0
        dp[0] = 1
        #dp[1] = 1
        for i in range(1,n+1):
            for j in range(1,i+1):
                dp[i] += dp[j-1] * dp[i-j]
               
            
        return dp[-1]