leetcode面试题 08.02. 迷路的机器人——由走迷宫引出的三种方法（dp,bfs,dfs）

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

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

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

bfs

需要每一次都重新copy之前的数组。
记住map<node,…>这样写的时候，map本是红黑树，node没有重载operator<,就没有办法排序了，所以要在结构体node里面重载<，不然会报错（这里卡了好久）
先判断迷宫边界，在判断有没有走到过这里

class Solution {
public:
    vector<vector<int>> pathWithObstacles(vector<vector<int>>& obstacleGrid) {
        vector<vector<int>> res;
        int r = obstacleGrid.size();
        if(r == 0) return {};
        if(r == 1 && obstacleGrid[0].size() == 1){
            if(obstacleGrid[0][0] == 1){
                return {};
            }else{
                res.push_back({0,0});
                return res;
            }
        }
        int c = obstacleGrid[0].size();
        if(obstacleGrid[0][0] == 1) return {};
        res.push_back({0,0});
        if(back_trace(obstacleGrid,res,0,0)){
            return res;
        }else{
            return {};
        }
    }


    bool back_trace(vector<vector<int>>& obstacleGrid,vector<vector<int>>&res,int r,int c){
        if(r == obstacleGrid.size() - 1&& c == obstacleGrid[0].size() - 1){
            return true;
        }

        int dx[2] = {0,1};
        int dy[2] = {1,0};
        obstacleGrid[r][c] = 2;
        for(int k = 0;k < 2;k++){
            int x = dx[k] + r;
            int y = dy[k] + c;
            if(x >= 0 && x < obstacleGrid.size() && y >= 0 && y < obstacleGrid[0].size()){
                if(obstacleGrid[x][y] == 0){
                    obstacleGrid[x][y] = 2;
                    res.push_back({x,y});
                    if(back_trace(obstacleGrid,res,x,y)){
                        return true;
                    }
                    obstacleGrid[x][y] = 3;
                    res.pop_back();
                }
            }
        }
        //obstacleGrid[r][c] = 0;
        return false;
    }
};

dfs

这道题目完全没必要回溯，因为如果一个坐标返回false，那么就意味着这个坐标是无法到达终点的，那么直接去掉坐标就行了。
为了优化空间，所以这里没有用visit 坐标访问情况，直接在原数组上面更改数值。

class Solution {
public:
    vector<vector<int>> pathWithObstacles(vector<vector<int>>& obstacleGrid) {
        vector<vector<int>> res;
        int r = obstacleGrid.size();
        if(r == 0) return {};
        if(r == 1 && obstacleGrid[0].size() == 1){
            if(obstacleGrid[0][0] == 1){
                return {};
            }else{
                res.push_back({0,0});
                return res;
            }
        }
        int c = obstacleGrid[0].size();
        if(obstacleGrid[0][0] == 1) return {};
        res.push_back({0,0});
        if(back_trace(obstacleGrid,res,0,0)){
            return res;
        }else{
            return {};
        }
    }


    bool back_trace(vector<vector<int>>& obstacleGrid,vector<vector<int>>&res,int r,int c){
        if(r == obstacleGrid.size() - 1&& c == obstacleGrid[0].size() - 1){
            return true;
        }

        int dx[2] = {0,1};
        int dy[2] = {1,0};
        obstacleGrid[r][c] = 2;
        for(int k = 0;k < 2;k++){
            int x = dx[k] + r;
            int y = dy[k] + c;
            if(x >= 0 && x < obstacleGrid.size() && y >= 0 && y < obstacleGrid[0].size()){
                if(obstacleGrid[x][y] == 0){
                    obstacleGrid[x][y] = 2;
                    res.push_back({x,y});
                    if(back_trace(obstacleGrid,res,x,y)){
                        return true;
                    }
                    obstacleGrid[x][y] = 3;
                    res.pop_back();
                }
            }
        }
        obstacleGrid[r][c] = 0;
        return false;
    }
};
/*
作者：vinny
链接：https://leetcode-cn.com/problems/robot-in-a-grid-lcci/solution/cpp-dfs-jian-zhi-by-vinny/
*/

dp

从后面往前面递推，就不需要每次都copy原来的数组

class Solution {
   public:
    vector<vector<int>> pathWithObstacles(vector<vector<int>>& obstacleGrid) {
        vector<vector<int>> res;

        int row = obstacleGrid.size();
        if (row == 0) return res;
        int col = obstacleGrid[0].size();
        if (col == 0) return res;

        // 起点或终点是障碍，不可能到达
        if (obstacleGrid[0][0] == 1 || obstacleGrid[row - 1][col - 1] == 1)
            return res;

        int dp[row + 1][col + 1];
        dp[0][0] = 1;
        // 初始化首列
        for (int i = 1; i < row; i++) {
            if (obstacleGrid[i][0] == 1) dp[i][0] = 0;
            else dp[i][0] = dp[i - 1][0];
        }
        // 初始化首行
        for (int i = 1; i < col; i++) {
            if (obstacleGrid[0][i] == 1) dp[0][i] = 0;
            else dp[0][i] = dp[0][i - 1];
        }
        // 求路径
        for (int i = 1; i < row; i++) {
            for (int j = 1; j < col; j++) {
                if (obstacleGrid[i][j] == 1) {
                    dp[i][j] = 0;
                } else { // 无需保存和，保存最大的即可
                    dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);//dp[i][j]=1就是可以走到这个位置的，只要能从左走到这或者上走到这就能走
                }
            }
        }

        // 到达终点的路径为0，直接返回
        if (dp[row - 1][col - 1] == 0) return res;

        // 从终点反推回起点
        int r = row - 1, c = col - 1;
        while (r != 0 || c != 0) {
            res.push_back({r, c});

            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--;//上面是1，可以从上面走过来
            else c--;//左边是1，可以从左边走过来
        }
        res.push_back({0, 0});
        // 注意路径反转
        reverse(res.begin(), res.end());
        return res;
    }
};

//作者：wushaoling