当前位置：首页 > article >正文

【算法题】63. 不同路径 II-力扣(LeetCode)-”如果起点有障碍物，那么便到不了终点“

article 2024/9/25 23:01:20

【算法题】63. 不同路径 II-力扣(LeetCode)-”如果起点有障碍物，那么便到不了终点“

1.题目

下方是力扣官方题目的地址

63. 不同路径 II

一个机器人位于一个 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.题解

这题有两种思路：

思路一：深度优先搜索

思路二：动态规划

思路一

路径问题我们很容易想到的是深度优先来搜索出路径，进而求出结果。

我们将路径想象成树结构，本题要求只能向下或者向右，那么这棵树就是一颗二叉树，如图所示：

在这里插入图片描述

在结合这颗树进行深度优先搜索的时候注意一下边界条件以及路径中的障碍物，这个问题就很容易解决出来了

Python代码

class Solution(object):
    def uniquePathsWithObstacles(self, obstacleGrid):
        """
        :type obstacleGrid: List[List[int]]
        :rtype: int
        """
        if obstacleGrid[0][0]==1:return 0 # 如果起点有障碍物，那么便到不了终点
        m=len(obstacleGrid)
        n=len(obstacleGrid[0])
        counts=0
        global counts
        def dfs(x,y):
            global counts
            if x==m-1 and y==n-1:
                counts+=1
                return
            for dx,dy in [[1,0],[0,1]]:
                if 0<=x+dx<m and 0<=y+dy<n:  # 确保不会越界
                    if obstacleGrid[x+dx][y+dy]!=1:dfs(x+dx,y+dy) # 以及不碰到障碍物
        dfs(0,0)
        return counts

不过显然这种方法比较低效，提交时显示的也是显示超时了

在这里插入图片描述

思路二

我们用dp[i,j]来表示从坐标 (0,0) 到坐标 (i,j) 的路径总数

那么dp[i,j]是怎么来的呢？

题目中要求只能向下或者向右走，那么反过来，坐标(i,j)只能由它的上方以及左方走过来，所以

dp[i,j]是dp[i-1,j]和dp[i,j-1]的路径总数的和

这里有一个细节需要注意：

dp元素的初始化值需要是0

这样即使(i,j)的左边或者上边有障碍物,也不影响得出的结果

所以我们可得出状态转移方程:

dp[i][j]=dp[i-1][j]+dp[i][j-1]

当然这题也有以下特殊的边界位置:第一行和第一列

其中起点位置最为特殊且如果起点有障碍物，那么无论无何也到不了终点：

if not obstacleGrid[0][0]:dp[0][0]=1
else:return 0

至于其它第一行的数，它们只能从左边走过来

以及其他第一列的数，它们只能从上边走过来

所以我们可以将它们先走完：

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

然后我们接着对剩下的位置进行模拟，利用状态转移方程，即可解决该问题

python代码

class Solution(object):
    def uniquePathsWithObstacles(self, obstacleGrid):
        """
        :type obstacleGrid: List[List[int]]
        :rtype: int
        """
        m=len(obstacleGrid)
        n=len(obstacleGrid[0])
        dp=[[0]*n for _ in range(m)]    # 初始化dp数组
        if not obstacleGrid[0][0]:dp[0][0]=1
        else:return 0  # 如果起点有障碍物，那么便到不了终点 
        for i in range(1,n):
            if not obstacleGrid[0][i]:dp[0][i]=dp[0][i-1]       # 将特殊值模拟完
        for j in range(1,m):
            if not obstacleGrid[j][0]:dp[j][0]=dp[j-1][0]
        for i in range(1,m):
            for j in range(1,n):                        # 模拟其他正常位置
                if not obstacleGrid[i][j]:
                    dp[i][j]=dp[i-1][j]+dp[i][j-1]      # 如果这个位置不是障碍物，则利用状态转移方程
        return dp[-1][-1]