研习代码 day34 | 初识动态规划——不同路径

一、不同路径

        1.1 题目

        一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。

        机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。

        问总共有多少条不同的路径？

示例 1：

输入：m = 3, n = 7
输出：28

示例 2：

输入：m = 3, n = 2
输出：3
解释：
从左上角开始，总共有 3 条路径可以到达右下角。
1. 向右 -> 向下 -> 向下
2. 向下 -> 向下 -> 向右
3. 向下 -> 向右 -> 向下

示例 3：

输入：m = 7, n = 3
输出：28

示例 4：

输入：m = 3, n = 3
输出：6

提示：

• 1 <= m, n <= 100
• 题目数据保证答案小于等于 2 * 10^9

        1.2 题目链接

        62.不同路径

        1.3 解题思路和过程想法

        （1）解题思路

        因为当前位置路径的选择与上一步有关，且每一步的操作都类似，采用动态规划。
        # 数组：dp[i][j] 记录左上角到(i,j)的路径数
        # 递推规律：因为每次只能向右或向下，所以 dp[i][j] = dp[i-1][j] + dp[i][j-1] 
        # 初始化：因为每次只能向右或向下，所以dp[0][i] == dp[i][0] == 1
        # 递推方向：因为每次只能向右或向下，所以从左往右，按层往下遍历

        （2）过程想法

        整体思路比较好构思

        1.4 代码

class Solution:
    def uniquePaths(self, m: int, n: int) -> int:
        # dp[i][j] 记录左上角到(i,j)的路径数
        dp = [[0]*n for _ in range(m)] 
        
        # 递推规律：因为每次只能向右或向下，所以 dp[i][j] = dp[i-1][j] + dp[i][j-1]

        # 初始化：因为每次只能向右或向下，所以dp[0][i] == dp[i][0] == 1
        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]

二、不同路径 II

        2.1 题目

        一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。

        机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish”）。

        现在考虑网格中有障碍物。那么从左上角到右下角将会有多少条不同的路径？

        网格中的障碍物和空位置分别用 1 和 0 来表示。

示例 1：

输入：obstacleGrid = [[0,0,0],[0,1,0],[0,0,0]]
输出：2
解释：3x3 网格的正中间有一个障碍物。
从左上角到右下角一共有 2 条不同的路径：
1. 向右 -> 向右 -> 向下 -> 向下
2. 向下 -> 向下 -> 向右 -> 向右

示例 2：

输入：obstacleGrid = [[0,1],[0,0]]
输出：1

提示：

• m == obstacleGrid.length
• n == obstacleGrid[i].length
• 1 <= m, n <= 100
• obstacleGrid[i][j] 为 0 或 1

        2.2 题目链接

        63.不同路径

        2.3 解题思路和过程想法

        （1）解题思路

        # 数组：用 obstacleGrid[i][j] 记录从左上角到 (i,j) 的路径数
        # 递推关系：因为每次只能向右或向下移动，所以递推关系 dp[i][j] = dp[i-1][j] + dp[i][j-1]
        # 初始化：将有障碍物的位置标记为 -1；因为每次只能向右或向下，将(0,i)和(i,0) 置为 1
        注：在处理第一列和第一列时，碰到障碍物则自动退出循环（剪枝）

        （2）过程想法

        总体思路和上一题差不多，只是需要提前判断是否会被障碍物影响

        2.4 代码

class Solution:
    def uniquePathsWithObstacles(self, obstacleGrid: List[List[int]]) -> int:
        # 数组：用 obstacleGrid[i][j] 记录从左上角到 (i,j) 的路径数

        # 递推关系：因为机器人每次只能向右或向下移动，所以递推关系 dp[i][j] = dp[i-1][j] + dp[i][j-1]

        # 初始化：将有障碍物的位置标记为 -1；因为每次只能向右或向下，将(0,i)和(i,0) 置为 1

        m = len(obstacleGrid)       # 行数
        n = len(obstacleGrid[0])    # 列数

        for i in range(m):
            for j in range(n):
                if obstacleGrid[i][j] == 1:
                    obstacleGrid[i][j] = -1

        flag_row = 0
        flag_col = 0
        for i in range(m):      # 第一列（碰到障碍物则自动退出循环）
            if obstacleGrid[i][0] != -1:        
                obstacleGrid[i][0] = 1
            else:
                flag_col = 1                               
                break

        for i in range(n):   # 第一行（碰到障碍物则自动退出循环）
            if obstacleGrid[0][i] != -1:  
                obstacleGrid[0][i] = 1  
            else:
                flag_row = 1                              
                break

        # 特殊情况：只有一行或一列，且有障碍物的情况
        if m == 1 or n == 1 :
            if flag_row == 1 or flag_col == 1:
                return 0
            else:
                return 1

        # 遍历方向：因为每一步只能向右或相下，所以从左往右，按层遍历
        for i in range(1,m):
            for j in range(1,n):
                # 本节点不是障碍物(若是障碍物，则不做修改)
                if obstacleGrid[i][j] != -1:
                    # 参考的两节点都不是障碍物
                    if obstacleGrid[i-1][j] != -1 and obstacleGrid[i][j-1] != -1:
                        obstacleGrid[i][j] = obstacleGrid[i-1][j] + obstacleGrid[i][j-1]
                    # 参考的两节点都是障碍物
                    elif obstacleGrid[i-1][j] == -1 and obstacleGrid[i][j-1] == -1:
                        obstacleGrid[i][j] = 0
                    # 参考的节点中有一个不可达点或障碍物
                    else:
                        obstacleGrid[i][j] = max(obstacleGrid[i][j-1],obstacleGrid[i-1][j])
        
        # 防止最终节点为障碍节点
        return max(obstacleGrid[-1][-1],0)