地牢逃脱

题目描述
给定一个 n 行 m 列的地牢，其中 ‘.’ 表示可以通行的位置，’X’ 表示不可通行的障碍，牛牛从 (x0 , y0 ) 位置出发，遍历这个地牢，和一般的游戏所不同的是，他每一步只能按照一些指定的步长遍历地牢，要求每一步都不可以超过地牢的边界，也不能到达障碍上。地牢的出口可能在任意某个可以通行的位置上。牛牛想知道最坏情况下，他需要多少步才可以离开这个地牢。

输入描述:

每个输入包含 1 个测试用例。每个测试用例的第一行包含两个整数 n 和 m（1 <= n, m <= 50），表示地牢的长和宽。接下来的 n 行，每行 m 个字符，描述地牢，地牢将至少包含两个 ‘.’。接下来的一行，包含两个整数 x0, y0，表示牛牛的出发位置（0 <= x0 < n, 0 <= y0 < m，左上角的坐标为 （0, 0），出发位置一定是 ‘.’）。之后的一行包含一个整数 k（0 < k <= 50）表示牛牛合法的步长数，接下来的 k 行，每行两个整数 dx, dy 表示每次可选择移动的行和列步长（-50 <= dx, dy <= 50）

输出描述:

输出一行一个数字表示最坏情况下需要多少次移动可以离开地牢，如果永远无法离开，输出 -1。以下测试用例中，牛牛可以上下左右移动，在所有可通行的位置.上，地牢出口如果被设置在右下角，牛牛想离开需要移动的次数最多，为3次。

解体思路：
使用广度优先搜索，在每一个点时试探所有给定的步长，如果下一点未出界且是一个可行的点，则将该点加入队列中。首先将牛牛所在原点加入队列，循环直至队列为空。由于需要使用广度搜索的层数，故每一个节点中不仅要存储x、y坐标，还要存储节点深度，由父节点拓展的子节点的深度等于父节点深度+1。
牛牛可否离开地牢的判断条件是：是否所有可通行的点都被遍历过了，如存在则返回-1，否则，返回所有节点的最大深度。

代码：

import java.util.Queue;
import java.util.Scanner;
import java.util.concurrent.LinkedBlockingQueue;

public class Main {
    public int n;
    public int m;
    public int x0;
    public int y0;
    public int stepNumber;
    public int count;

    public char[][] map;
    public int[][] step;
    //标记数组
    public int[][] flag;
    // 广度优先搜索需要维护一个队列
    public Queue<Node> queue = new LinkedBlockingQueue();

    public int cal() {
        int x = -1;
        int y = -1;
        queue.add(new Node(x0, y0,0));
        count = 0;
        while (!queue.isEmpty()) {
            // 向各个允许方向前进
            Node node = queue.poll();
            flag[node.x][node.y] = 1;
            for (int i = 0; i < stepNumber; i++) {
                x = node.x + step[i][0];
                y = node.y + step[i][1];
                if (isInMap(x, y)&&map[x][y] != 'X' && flag[x][y] == 0) {
                    queue.add(new Node(x, y,node.deep+1));
                    flag[x][y] = 1;
                }
            }
            count = node.deep;
        }
        for (int i = 0; i < n; i++)
            for (int j = 0; j < m; j++)
                if (flag[i][j] == 0&&map[i][j] =='.') {
                    return -1;
                }
        return count;
    }

    public boolean isInMap(int x,int y){
        if(x>=0&&x<n&&y>=0&&y<m)
            return true;
        return false;
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        Main myMain = new Main();
        myMain.n = scanner.nextInt();
        myMain.m = scanner.nextInt();
        myMain.map = new char[myMain.n][myMain.m];
        String string;
        scanner.nextLine();
        for (int i = 0; i < myMain.n; i++){
            string = scanner.nextLine();
            for (int j = 0; j < myMain.m; j++)
                 myMain.map[i][j] = string.charAt(j);
        }
        myMain.x0 = scanner.nextInt();
        myMain.y0 = scanner.nextInt();
        myMain.stepNumber = scanner.nextInt();
        myMain.step = new int[myMain.stepNumber][2];
        scanner.nextLine();
        for (int i = 0; i < myMain.stepNumber; i++) {
            string = scanner.nextLine();
            String[] strings = string.split(" ");
            myMain.step[i][0] = Integer.parseInt(strings[0]);
            myMain.step[i][1] = Integer.parseInt(strings[1]);
        }
        myMain.flag = new int[myMain.n][myMain.m];
        for (int i = 0; i < myMain.n; i++)
            for (int j = 0; j < myMain.m; j++)
                myMain.flag[i][j] = 0;
        scanner.close();
        System.out.println(myMain.cal());
    }

    private class Node {
        public int x;
        public int y;
        public int deep;

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