【无标题】

63. 不同路径 II

难度中等1011收藏分享切换为英文接收动态反馈

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

回溯算法

package com.company;

class Solution {
    public int uniquePaths(int m, int n) {
        int[][] grid = {{0,0,0},{0,1,0},{0,0,0}};
        boolean[][] visited = new boolean[m][n];
        backtrack(grid, visited, 0, 0, m - 1, n - 1);
        return count;
    }

    public static int count = 0; // 用于记录不同路径数量

    private void backtrack(int[][] grid, boolean[][] visited, int row, int col, int m, int n) {
        if (row == m && col == n) { // 当前位置为目标位置
            count++; // 找到一条新的路径，路径数量加1
            return;
        }
        if (row > m || col > n || visited[row][col]||grid[row][col]==1) { // 越界或当前位置已经被访问过，不能继续走
            return;
        }
        visited[row][col] = true; // 标记当前位置已经被访问
        backtrack(grid, visited, row, col + 1, m, n); // 向右走一步
        backtrack(grid, visited, row + 1, col, m, n); // 向下走一步
        visited[row][col] = false; // 撤销当前选择，回溯到上一步
    }

    public static void main(String[] args) {
        Solution solution = new Solution();
        int m = 3;
        int n = 3;
        int paths = solution.uniquePaths(m, n);
        System.out.println("The number of unique paths from top-left to bottom-right is: " + paths);
    }
}

动态规划

class Solution {
    public static void main(String[] args) {
        // 测试用例
        int[][] obstacleGrid = {{0,0,0},{0,1,0},{0,0,0}};
        int result = uniquePathsWithObstacles(obstacleGrid);
        System.out.println(result);
    }

    public static int uniquePathsWithObstacles(int[][] obstacleGrid) {
        int m = obstacleGrid.length;
        int n = obstacleGrid[0].length;
        int[][] dp = new int[m][n];

        // 如果在起点或终点出现了障碍，直接返回0
        if (obstacleGrid[m - 1][n - 1] == 1 || obstacleGrid[0][0] == 1) {
            return 0;
        }

        // 初始化第一列，当遇到障碍时，后面的都无法到达，因此直接退出循环
        for (int i = 0; i < m && obstacleGrid[i][0] == 0; i++) {
            dp[i][0] = 1;
        }

        // 初始化第一行，当遇到障碍时，后面的都无法到达，因此直接退出循环
        for (int j = 0; j < n && obstacleGrid[0][j] == 0; j++) {
            dp[0][j] = 1;
        }

        // 从第二行第二列开始计算，如果当前格子有障碍，则不能到达，路径数为0，否则等于上方和左方的路径数之和
        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                dp[i][j] = (obstacleGrid[i][j] == 0) ? dp[i - 1][j] + dp[i][j - 1] : 0;//这行会给它不可达的赋值为0
            }
        }

        // 返回到达终点的路径数
        return dp[m - 1][n - 1];
    }
}