leetcode：1091. 二进制矩阵中的最短路径

最新推荐文章于 2024-05-08 20:54:14 发布

OceanStar的学习笔记

最新推荐文章于 2024-05-08 20:54:14 发布

阅读量527

点赞数

分类专栏：算法与数据结构文章标签： leetcode 矩阵深度优先

原文链接：https://leetcode.cn/problems/shortest-path-in-binary-matrix/

版权

算法与数据结构专栏收录该内容

1121 篇文章 76 订阅

订阅专栏

题目来源

1091. 二进制矩阵中的最短路径

题目描述

在这里插入图片描述

题目解析

典型的BFS最短路径问题，用DFS也可以求解，但是容易超时。

什么时候用BFS，什么时候DFS

如果只是要找到某一个结果是否存在，那么DFS会更加高效。因为DFS会首先把一种可能的情况尝试到底，才会回溯去尝试下一种情况，只要找到一种情况，就可以返回了。但是BFS必须所有可能的情况同时尝试，在找到一种满足条件的结果的同时，也尝试了很多不必要的路径
如果是要找可能结果中最短的，那么BFS会更加高效。因为DFS是一种一种的尝试，把所有的可能情况完成之前，无法确定哪个是最短，所以DFS必须把所有情况都找一遍，才能确定最终答案（DFS的优化就是剪枝，不剪枝很容易超时）。而BFS从一开始就是尝试所有情况，所以只要找到第一个达到的那个点，那就是最短的路径，可以直接返回了，其他情况都可以省略了，所以这种情况下，BFS更高效。

BFS

class Solution {
public:
    //转换为图：0是通路，八向连通
    int shortestPathBinaryMatrix(vector<vector<int>>& grid) {
        int N = grid.size();
        if(grid[0][0] == 1 || grid[N - 1][N - 1] == 1){
            return -1;
        }
        if (N == 1) {
            return 1;
        }
        std::vector<std::vector<int>> dirs {{-1,0},{-1,1},{0,1},{1,1},{1,0},{1,-1},{0,-1},{-1,-1}};
        std::queue<std::pair<int, int>> queue;
        queue.push({0, 0});
        grid[0][0] = 1;
        int step = 1;
        while (!queue.empty()){
            int width = queue.size();
            for (int i = 0; i < width; ++i) {
                auto idx = queue.front(); queue.pop();
                for(auto dir : dirs){
                    int nx = idx.first + dir[0], ny = idx.second + dir[1];
                    if(nx < 0 || ny < 0 || nx == N || ny == N || grid[nx][ny] == 1){
                        continue;
                    }
                    if(nx == N - 1 && ny == N - 1){
                        return step + 1;
                    }
                    queue.push({nx, ny});
                    grid[nx][ny] = 1;
                }
            }
            step++;
        }
        return -1;
    }
};

DFS

class Solution {
    std::vector<std::vector<int>> dirs {
            {0, -1},{0, 1}, {-1, 0}, {1, 0},
            {1, -1},{-1, 1},{1, 1},{-1, -1}
    };
    int process(vector<vector<int>> &grid, int i, int j, int N){
        if(i < 0 || j < 0 || i >= N || j >= N || grid[i][j] == 1){
            return INT_MAX;
        }

        if(i == N - 1 && j == N - 1){
            return 1;
        }


        int maxpath = INT_MAX;
        grid[i][j] = 1;
        for(auto dir : dirs){
            int path = process(grid, i + dir[0], j + dir[1], N);
            maxpath =  std::min(maxpath, path);
        }
        grid[i][j] = 0;
        return maxpath == INT_MAX ? INT_MAX : maxpath + 1;
    }
public:
    int shortestPathBinaryMatrix(vector<vector<int>>& grid) {
        int N = grid.size();
        if(grid[0][0] == 1 || grid[N - 1][N - 1] == 1){
            return -1;
        }

        int path = process(grid, 0, 0, N);
        return path == INT_MAX  ? -1 : path;
    }
};