仙岛求药

少年李逍遥的婶婶病了，王小虎介绍他去一趟仙灵岛，向仙女姐姐要仙丹救婶婶。叛逆但孝顺的李逍遥闯进了仙灵岛，克服了千险万难来到岛的中心，发现仙药摆在了迷阵的深处。迷阵由 M \times NM×N 个方格组成，有的方格内有可以瞬秒李逍遥的怪物，而有的方格内则是安全。现在李逍遥想尽快找到仙药，显然他应避开有怪物的方格，并经过最少的方格，而且那里会有神秘人物等待着他。现在要求你来帮助他实现这个目标。

输入格式
第一行输入两个非零整数 MM 和 NN，两者均不大于 2020。MM 表示迷阵行数, NN 表示迷阵列数。

接下来有 MM 行, 每行包含 NN 个字符,不同字符分别代表不同含义:

1. ‘@’：少年李逍遥所在的位置；2) ‘.’：可以安全通行的方格；3) ‘#’：有怪物的方格；4) ‘*’：仙药所在位置。

输出格式
输出一行，该行包含李逍遥找到仙药需要穿过的最少的方格数目(计数包括初始位置的方块)。如果他不可能找到仙药, 则输出 -1−1。

输出时每行末尾的多余空格，不影响答案正确性

样例输入1 复制
8 8
.@##…#
#…#.#
#.#.##…
…#.###.
#.#…#.
…###.#.
…#.…
.#…###
样例输出1 复制
10
样例输入2 复制
6 5
..#.
.#…
…##.
…
.#…
…@
样例输出2 复制
8
样例输入3 复制
9 6
.#…#.
.#.*.#
.####.
…#…
…#…
…#…
…#…
#.@.##
.#…#.
样例输出3 复制
-1

套用bfs模板，染色加队列，因为bfs算出来始终一定是最小值，所以不用担心是否为最小值的问题

import java.util.Scanner;

/**
 * Created on 09:32  23/02/2020
 * Description:
 *
 * @author Weleness
 */

public class Main {

    private static class Node {
        int x;
        int y;
        int step;

        public Node() {
        }

        public Node(int x, int y, int step) {
            this.x = x;
            this.y = y;
            this.step = step;
        }
    }

    private static int N = 3000;
    private static int r, c;
    private static char[][] map = new char[N][N];
    private static boolean[][] vis = new boolean[N][N];
    private static int[][] dir = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
    private static Node[] q = new Node[N];

    /**
     * @param sx 起点x
     * @param sy 起点y
     * @param ex 终点x
     * @param ey 终点y
     * @Method Description:
     * TODO  BFS
     * @Author weleness
     * @Return
     */
    private static void bfs(int sx, int sy, int ex, int ey) {
        int head = 1, tail = 1;
        boolean flag1 = true;
        vis[sx][sy] = true; // 标记走过
        Node n = new Node(sx, sy, 0);
        q[tail] = n;
        ++tail;
        while (head < tail) {
            int x = q[head].x;
            int y = q[head].y;
            int step = q[head].step;
            if (x == ex && y == ey) {
                flag1 = false;
                System.out.println(step);
                break;
            }
            for (int i = 0; i < 4; i++) {
                int nx = x + dir[i][0];
                int ny = y + dir[i][1];
                if (nx >= 0 && nx < r && ny >= 0 && ny < c && !vis[nx][ny] && map[nx][ny] == '.') {
                    vis[nx][ny] = true;
                    Node nn;
                    if (q[tail] == null) {
                        nn = new Node();
                    } else {
                        nn = q[tail];
                    }

                    nn.x = nx;
                    nn.y = ny;
                    nn.step = step + 1;
                    q[tail++] = nn;
                }
            }
            head++;
        }
        if (flag1)
            System.out.println(-1);
    }

    public static void main(String[] args) {
        int sx = 0,sy = 0,ex = 0,ey = 0;
        Scanner sc = new Scanner(System.in);
        r = sc.nextInt();
         c = sc.nextInt();
        for (int i = 0; i < r; i++) {
            String s = sc.next();
            map[i] = s.toCharArray();
        }
        for (int i = 0; i < r; i++) {
            for (int j = 0; j < c; j++) {
                if(map[i][j] == '@'){
                    sx = i;
                    sy = j;
                }else if(map[i][j] == '*'){
                    ex = i;
                    ey = j;
                    map[i][j] = '.';
                }
            }
        }
        bfs(sx,sy,ex,ey);
    }
}