【数据结构】二进制矩阵中的最短路径 Shortest Path In Binary Matrix

目录

• 二进制矩阵中的最短路径 Shortest Path In Binary Matrix
• 思路
• Tag

二进制矩阵中的最短路径 Shortest Path In Binary Matrix

给定一个N*N矩阵grid，返回一个最短路径，如果没有就返回-1；

最短路径：从grid的左上角[0,0]开始，直到右下角[n-1,n-1]，所有路径上的点必须是0，

路径可以是上下左右，还可以是左上左下，右上右下。

grid = [[0,1],[1,0]]
out：2

思路

grid是一个N*N阶矩阵，要求输出最短路径。

使用BFS,将grid左上角0元素坐标信息入队。并且使用一个visit二维数组记录结果，-1代表未访问过，0代表访问过.

队列中使用数组维护已经遍历的坐标信息 {x,y,val},代表行，列，节点的最短路径

在进行BFS过程中，每出队一个坐标，就对该坐标进行方向扩展，即寻找附近的元素坐标。直到走到右下角，或者无法找到最短路径返回-1。

 public int shortestPathBinaryMatrix(int[][] grid) {
        int n = grid.length;
        int m = grid[0].length;
        int[][] visit = new int[n][m];
        if (grid[0][0]==1){
            return -1;
        }
        Queue<int[]> queue = new LinkedList<int[]>();

        int[][] dir = {{1,0},{-1,0},{0,1},{0,-1},{-1,-1},{-1,1},{1,1},{1,-1}};

        for(int i=0;i<n;i++){
            for(int j=0;j<m;j++){
                if(grid[i][j]==0){
                    visit[i][j]= -1;
                }

            }
        }
        queue.offer(new int[]{0,0,1});
        visit[0][0]=1;
        int ans =0;
        while(!queue.isEmpty()){
            int[] t = queue.peek();
            if(t[0]==n-1&&t[1]==m-1){
                return t[2];
            }
            for(int k = 0;k<8;k++){
                int x = t[0]+dir[k][0];
                int y = t[1]+dir[k][1];
                if(x<0||x>=n){
                    continue;
                }
                if(y<0||y>=m){
                    continue;
                }
                if(grid[x][y]==1){
                    continue;
                }
                if(visit[x][y] ==1){
                    continue;
                }
                ans = t[2]+1;
                visit[x][y]=1;
                queue.offer(new int[]{x,y,ans});
            }
            queue.poll();
        }
        return -1;
    }

Tag

BFS