Recorriendo el laberinto del problema BFS clásico

información del tema

Dada una matriz bidimensional de números enteros de n × m, utilizada para representar un laberinto, la matriz contiene solo 0 o 1, donde 0 representa el camino que se puede caminar y 1 representa la pared que no se puede pasar.

Inicialmente, hay una persona ubicada en la esquina superior izquierda (1,1), y se sabe que la persona puede moverse una posición a la vez en cualquiera de las direcciones arriba, abajo, izquierda y derecha.

¿Cuántas veces necesita la persona moverse de la esquina superior izquierda a la esquina inferior derecha (n,m)?

Los datos garantizan que los números en (1,1) y (n,m) son 0 y debe haber al menos una ruta.

formato de entrada

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

formato de salida

Las siguientes n líneas, cada una de las cuales contiene m enteros (0 o 1), representan el laberinto de matriz bidimensional completo.

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

rango de datos

1≤n,m≤100

Ejemplo:

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

Salida de muestra:

8

ideas

El peso de cada borde del laberinto en la pregunta es el mismo, 0 o 1. Representa poder caminar o no. Usa una cola para almacenar las posibilidades de cada intento en cuatro direcciones. Siga intentándolo cuando la cola no esté vacía, la primera ruta recorrida es la ruta más corta. Porque cada vez es un paso, el mismo número de pasos, el plan que llegue primero, el que sea más corto.

código

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]);
    }
}