经典BFS问题之走迷宫

题目信息

给定一个 n×m 的二维整数数组，用来表示一个迷宫，数组中只包含 0 或 1，其中 0 表示可以走的路，1 表示不可通过的墙壁。

最初，有一个人位于左上角 (1,1) 处，已知该人每次可以向上、下、左、右任意一个方向移动一个位置。

请问，该人从左上角移动至右下角 (n,m) 处，至少需要移动多少次。

数据保证 (1,1) 处和 (n,m) 处的数字为 0，且一定至少存在一条通路。

输入格式

第一行包含两个整数 n 和 m。

输出格式

接下来 n 行，每行包含 m 个整数（0 或 1），表示完整的二维数组迷宫。

输出一个整数，表示从左上角移动至右下角的最少移动次数。

数据范围

1≤n,m≤100

样例：

5 5
0 1 0 0 0
0 1 0 1 0
0 0 0 0 0
0 1 1 1 0
0 0 0 1 0

输出样例：

8

思路

题目中迷宫每个边的权值都是相同的，0或者1。代表能走或者不能走。用队列来存储每次向四个方向尝试的可能。当队列不空时一直尝试，第一次遍历到的路径就是最短的路径。因为每次都是走一步，相同的步数，哪个方案谁先到，谁就是最短的。

代码

import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;


class  pair{
    
    
    int x;
    int y;
    public  pair(int x,int y){
    
    
        this.x=x;
        this.y=y;
    }
}
public class Main {
    
    
// 数据范围最大值
    static  int N=110;
    //存输入的地图
    static  int map[][]=new int[N][N];
    //存路径
    static int d[][]=new int[N][N];
    public static void main (String[] args) {
    
    
        Scanner sc=new Scanner (System.in);
        int n=sc.nextInt ();
        int m=sc.nextInt ();
        for (int i = 0 ; i <n  ; i++) {
    
    
            for (int j = 0 ; j < m ; j++) {
    
    
                map[i][j]=sc.nextInt ();
            }
        }
        bfs(n,m);
    }
   static void  bfs(int n,int m){
    
    
       Queue<pair> queue=new LinkedList<> ();
       queue.offer (new pair (0,0));
       //dx,dy数组用来判断四个方向
       int[] dx ={
    
    -1,0,1,0};
       int[] dy ={
    
    0,1,0,-1};
       while (!queue.isEmpty ()){
    
    
           pair pair=queue.poll ();
           //走到头了
           if(pair.x==n-1 && pair.y==m-1){
    
    
               break;
           }
           //遍历四个方向
           for (int i = 0 ; i <4  ; i++) {
    
    
               int x=dx[i]+pair.x;
               int y=dy[i]+ pair.y;
               //当x，y均大于0并且小于n，并且没有走过，并且可以走的情况下，才入队。
               if(x>=0 && y>=0 && x<n && y<m &&d[x][y]==0 && map[x][y]==0 ){
    
    
                   queue.offer (new pair (x,y));
                   //d存储的是路径，每走一步，就应该给步数+1
                   d[x][y]=d[pair.x][pair.y]+1;
               }
           }
       }
       System.out.println (d[n-1][m-1]);
    }
}