代码随想录算法训练营第三十四天 | 62.不同路径、63. 不同路径 II、343. 整数拆分、96. 不同的二叉搜索树

一、62.不同路径

题目链接：62. 不同路径 - 力扣（LeetCode）
文章讲解：代码随想录 (programmercarl.com)——62.不同路径
视频讲解：动态规划中如何初始化很重要！| LeetCode：62.不同路径_哔哩哔哩_bilibili

动态规划五部曲：
1. 确定 dp 数组及下标含义：dp[ i ][ j ]代表从 (0, 0) 到 (i , j) 有多少种不同的路径
2. 确定递推公式：只能由上推下或左推右 ，dp[ i ][ j ] = dp[ i - 1 ][ j ] + dp[ i ][ j - 1 ]，其中
dp[ i - 1 ][ j ] 代表走到 [ i ][ j ] 上面格子有多少种路径，dp[ i ][ j - 1 ] 代表走到 [ i ][ j ] 左面格子有多少种路径
3. 确定dp数组如何初始化：最上面一行 dp[ 0 ][ j ] 和最右面一列 dp[ i ][ 0 ] ，都只有一种路径，即for i in range(m): dp[ i ][ 0 ] = 1
for j in range(n): dp[ 0 ][ j ] = 1
4. 确定遍历顺序：从左向右遍历，从上向下遍历
5. 举例推导dp数组。

class Solution:
    def uniquePaths(self, m: int, n: int) -> int:
        # 创建 m × n 的dp数组
        dp = [[0] * n for _ in range(m)]

        # 初始化
        for i in range(m):
            dp[i][0] = 1
        for j in range(n):
            dp[0][j] = 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[m - 1][n - 1]

二、63. 不同路径 II

题目链接：63. 不同路径 II - 力扣（LeetCode）
文章讲解：代码随想录 (programmercarl.com)——63. 不同路径 II
视频讲解：动态规划，这次遇到障碍了| LeetCode：63. 不同路径 II_哔哩哔哩_bilibili

动态规划五部曲：
1. 确定 dp 数组及下标含义：dp[ i ][ j ]代表从 (0, 0) 到 (i , j) 有多少种不同的路径
2. 确定递推公式：同上一道题，但是需要加条件，if obs[ i ][ j ] == 0: dp[ i ][ j ] = dp[ i - 1 ][ j ] + dp[ i ][ j - 1 ]
3. 确定dp数组如何初始化：最上面一行 dp[ 0 ][ j ] 和最右面一列 dp[ i ][ 0 ] ，都只有一种路径，即for i in range(m): 
        if obs[ i ][ 0 ] == 0:
                dp[ i ][ 0 ] = 1
        else:
                break

for j in range(n): 
        if obs[ 0 ][ j ] == 0:
                dp[ 0 ][ j ] = 1
        else:
                break
4. 确定遍历顺序：从左向右遍历，从上向下遍历
5. 举例推导dp数组。

class Solution:
    def uniquePathsWithObstacles(self, obstacleGrid: List[List[int]]) -> int:
        # 统计行列数
        m = len(obstacleGrid)
        n = len(obstacleGrid[0])

        # 起始位置，终止位置有障碍，return 0
        if obstacleGrid[0][0] == 1 or obstacleGrid[m - 1][n - 1] == 1:
            return 0

        # 创建 m × n 的全 0 数组
        dp = [[0] * n for _ in range(m)]

        # 初始化
        for i in range(m):
            if obstacleGrid[i][0] == 0:
                dp[i][0] = 1
            else:
                break
        
        for j in range(n):
            if obstacleGrid[0][j] == 0:
                dp[0][j] = 1
            else:
                break

        # 确定递推公式
        for i in range(1, m):
            for j in range(1, n):
                if obstacleGrid[i][j] == 0:
                    dp[i][j] = dp[i - 1][j] + dp[i][j - 1]

        return dp[m - 1][n - 1]

三、343. 整数拆分（可跳过）

题目链接：343. 整数拆分 - 力扣（LeetCode）
文章讲解：代码随想录 (programmercarl.com)——343. 整数拆分
视频讲解：动态规划，这次遇到障碍了| LeetCode：63. 不同路径 II_哔哩哔哩_bilibili

思路：拆成m个近似相同的数，最大值在其中，比如100可以拆成50×50，33×33×34，25×25×25×25……，最大值为其中之一。

动态规划五部曲：
1. 确定 dp 数组及下标含义：dp[ i ] 表示对 i 进行拆分得到的最大乘积。
2. 确定递推公式：拆成3个数及以上， j × dp[ i - j ]，固定j，去拆 i - j。
dp[ i ] = max( j × ( i - j ), j × dp[ i - j ], dp[ i ] );
3. 确定dp数组如何初始化：dp[ 0 ] 和 dp [ 1 ] 都没有意义，dp[ 2 ] = 1
4. 确定遍历顺序：
for i in range(3, n):
        for j in range(1, i):
5. 举例推导dp数组。

class Solution:
    def integerBreak(self, n: int) -> int:
        # 初始化dp存储结果
        dp = [0] * (n + 1)

        # 初始化dp数组
        dp[2] = 1

        for i in range(3, n + 1):
            for j in range(1, i):
                # 里面dp[i]是为了记录前面已经完成拆分的最大情况
                dp[i] = max(dp[i], j * (i - j), j * dp[i - j])

        return dp[n]

四、96. 不同的二叉搜索树（可跳过）

题目链接：96. 不同的二叉搜索树 - 力扣（LeetCode）
文章讲解：代码随想录 (programmercarl.com)——96. 不同的二叉搜索树
视频讲解：动态规划，这次遇到障碍了| LeetCode：63. 不同路径 II_哔哩哔哩_bilibili

思路：只跟布局有关，以n = 3为例，
总和 = 头节点为1的情况 + 头节点为2的情况 + 头节点为3的情况，
头节点为1 = 左子树0节点 × 右子树2节点
头节点为2 = 左子树1节点 × 右子树1节点
头节点为3 = 左子树2节点 × 右子树0节点
dp[ 3 ] = dp[ 0 ] × dp[ 2 ] + dp[ 1 ] × dp[ 1 ] + dp[ 2 ] × dp[ 0 ]

动态规划五部曲：
1. 确定 dp 数组及下标含义：输入 i 有 dp[ i ] 种不同的二叉搜索树，输出 dp[ n ]
2. 确定递推公式：以 j 为头节点，左子树有 (j - 1) 个节点，右子树有 (i - j) 个节点，
dp[ i ] += dp[ j - 1 ] × dp[ i - j ]
3. 确定dp数组如何初始化：dp[ 0 ] = 1; dp[ 1 ] = 1
4. 确定遍历顺序：从小到大遍历
5. 举例推导dp数组。

class Solution:
    def numTrees(self, n: int) -> int:
        # 创建dp列表存储结果
        dp = [0] * (n + 1)

        # 初始化
        dp[0] = 1
        dp[1] = 1

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

        return dp[n]