【力扣面试】面试题 08.02. 迷路的机器人（dp）

面试题 08.02. 迷路的机器人

题目

设想有个机器人坐在一个网格的左上角，网格 r 行 c 列。机器人只能向下或向右移动，但不能走到一些被禁止的网格（有障碍物）。设计一种算法，寻找机器人从左上角移动到右下角的路径。

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

返回一条可行的路径，路径由经过的网格的行号和列号组成。左上角为 0 行 0 列。如果没有可行的路径，返回空数组。

输入:
[
   [0,0,0],
   [0,1,0],
   [0,0,0]
]
输出: [[0,0],[0,1],[0,2],[1,2],[2,2]]
解释:
输入中标粗的位置即为输出表示的路径，即
0行0列（左上角） -> 0行1列 -> 0行2列 -> 1行2列 -> 2行2列（右下角)

说明：r 和 c 的值均不超过 100。

解题思路

思路：

定义： dp[i] [j] 表示机器人是否能走到（i，j）位置。

初始化：

• dp[0] [0]=1；
• 第一行和第一列要单独处理。计算首行和首列: 判断左边或者上面是否为true且当前是否有障碍;

计算：

当前格子的状态，取决于，它左边，或者它上面。
1、 obstacleGrid[i][j] = 1的情况：dp[i][j] = 0;

2、obstacleGrid[i][j] = 0的情况：dp[i][j] = max(d[i-1][j], d[i][j-1]) 取两种情况(左和上)的最大值。

结果：

1、如果走到终点，dp[m][n]==0;表示没有路径，返回空数组

2、dp[r-1][c-1]=1：倒推回去求任意一条路径，无需判断最短，只要一条可以一直走下去的路径就可以。因为插入路径是倒序，最后倒序后就是结果。

代码

class Solution {
    public List<List<Integer>> pathWithObstacles(int[][] obstacleGrid) {

        List<List<Integer>> res = new ArrayList<>();
        int m = obstacleGrid.length;
        int n = obstacleGrid[0].length;
        int[][] dp = new int[m][n];

        //判断起点和终点都是障碍物的情况，
        if (obstacleGrid[0][0] == 1 || obstacleGrid[m - 1][n - 1] == 1) {
            return res;
        }

        dp[0][0] = 1;
        //处理第一行
        for (int i = 1; i < n; i++) {
            if (obstacleGrid[0][i] == 1) {
                dp[0][i] = 0;
            } else {
                dp[0][i] = dp[0][i - 1];
            }
        }

        //处理第一列
        for (int i = 1; i < m; i++) {
            if (obstacleGrid[i][0] == 1) {
                dp[i][0] = 0;
            } else {
                dp[i][0] = dp[i - 1][0];
            }
        }

        //计算状态转移方程
        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                if (obstacleGrid[i][j] == 1) {
                    dp[i][j] = 0;
                } else {
                    dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
                }
            }
        }
        //如果走到终点，dp[m-1][n-1]==0;表示没有路径
        if (dp[m - 1][n - 1] == 0) {
            return res;
        }
        int r = m - 1, c = n - 1;

        while (r != 0 || c != 0) {
            List<Integer> list = new ArrayList<>();
            list.add(r);
            list.add(c);
            res.add(list);

            int up = 0;
            if (r > 0) {
                up = dp[r - 1][c];
            }
            int left = 0;
            if (c > 0) {
                left = dp[r][c - 1];
            }
            if (up >= left) {
                r--;
            } else {
                c--;
            }
        }

        List<Integer> list = new ArrayList<>();
        list.add(0);
        list.add(0);
        res.add(list);

        Collections.reverse(res);

        return res;
    }
}

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/robot-in-a-grid-lcci