迷宫的最短路径 BFS JAVA

用队列实现BFS: java.util.Queue

初始化一个无穷大的数INF，准备一个距离二维数组，数组规模与输入相匹配，每一元素初始化为INF。这个距离二维数组可以记录从起点到当前位置的距离，也可以作为记忆化使用(即当前位置存储的距离 != INF)。

迷宫地图：

/*
10
#S######.#
......#..#
.#.##.##.#
.#........
##.##.####
....#....#
.#######.#
....#.....
.####.###.
....#...G#
*/

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

public class Main {
    public static  final int INF = 10000000;
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        char [][] c = new char[n][];
        for (int i = 0; i < n; i++) {
            c[i] = scan.next().toCharArray();
        }
        /* 打印迷宫 */
//        for (int i = 0; i < n; i++) {
//            for (int j = 0; j < c[0].length; j++) {
//                System.out.print(c[i][j]+" ");
//            }
//            System.out.println();
//        }
        int beginX = 0,beginY = 1;
        int endX = 9,endY = 8;
        int [][] d = new int[n][n];
        int [][] dx ={{1,0},{-1,0},{0,1},{0,-1}};
        for (int i = 0; i < d.length; i++) {
            for (int j = 0; j < d[0].length; j++) {
                d[i][j] = INF;
            }
        }

        int [] index = {beginX,beginY};
        Queue<int[]> que = new LinkedList<>();
        que.offer(index);
        d[index[0]][index[1]] = 0;

        while (!que.isEmpty()){
            int [] headIndex = que.poll();
            if(headIndex[0] == endX && headIndex[1] == endY){
                break;
            }
            for (int i = 0; i < 4; i++) {
                int nx = headIndex[0]+dx[i][0],ny = headIndex[1]+dx[i][1];
                int []  nextIndex = {nx,ny};
                if(nx>=0 && nx <n && ny>=0 && ny<n && c[nx][ny]!='#' && d[nx][ny] == INF){
                    que.offer(nextIndex);
                    d[nx][ny] = d[headIndex[0]][headIndex[1]] + 1;
                }
            }
        }
        
        System.out.println(d[endX][endY]);
    }
}