清晰解题： 网易编程地牢逃脱

[编程题] 地牢逃脱

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

输入描述:

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

输出描述:

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

输入例子:

3 3
...
...
...
0 1
4
1 0    
0 1
-1 0
0 -1

输出例子:

3

难点

• 晦涩的题意（差评！）

  • 首先需要明确 题目中说“每一步只能按照一些指定的步长遍历地牢”， 是指主人公行走的方式可以从给定的几种方式中任意选取一种， 而且相同的行走方式可以被重复选取。

  • 其次 题目中说“最坏情况下，他需要多少步才可以离开这个地牢。” 是指， 在给定地牢的形状后，出口允许设置在任意一个“.”所在的位置，主人公在知道了出口点后，会试图以最短的路径走向出口，现在需要求，如果把出口设在了一个最难以到达的位置， 需要多少步才能到达出口点。

• 解题思路：
  
  • 明确了题意后，思路比较简单，唯一需要的知识储备是， 广度优先搜索BFS
  • 我作为一个没有知识储备的人，第一个困惑时，为什么广度优先搜索求出的是最短路径？
    
    • 这一点是被被严格证明过的，但直觉的思路是， 广度优先算法是一种逐层向外探索的算法，所以越靠近出发点的位置或越早被访问到， 每当到达一个尚未被访问过的结点时， 记录下当前所走的步数，该步数必然是最短的步数，最短步数走法可能不止一种。

纸上得来终觉浅，程序员的坑还是要自己填，参考链接2016网易内推笔试编程题合集（一）的代码，自己还是按照Java的写了一份自己的去提交， 发现了几个易错的点。

值得注意的地方：

• 题目中的x, y 坐标和平时习惯的x,y方向并不一轴，题目中的x是纵轴方向， y是横轴方向， 因为初始化二维数组保存的地图map时, 是map[x][y] 的方式来循环赋值的
• 基于上一点， 检查一个点是否可以行走时，需要注意， x对应的是n , y对应是m
• Java里面静态内部类在这里的使用简化了Point对象的构造方式，如果不用static修饰， 则不能在main方法中直接调用new Point() 而必须通过new Main（）.new Point（）方式创建

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


public class Main {
    static class Point {
        int x, y;
        int step;
        boolean visited = false;
        boolean reachable = false;

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

        public Point() {
            // TODO Auto-generated constructor stub
        }

    }

    static int n, m; // map has n rows and m columns
    static int x0, y0; // start point
    static int stepTypes; // the ways to walk in each step
    static int dx[] = new int[50], dy[] = new int[50];// dx ,dy对应每一步可以走的移动量
                                                        // dx=0,dy=1 为向右走一格。
    static Point map[][] = new Point[50][50];

    static{
        for (int i = 0; i < map.length; i++) {
            for (int j = 0; j < map[i].length; j++) {
                map[i][j]= new Point();
            }
        }

    }
    public static int max(int x, int y)
    {
        return x > y? x: y;
    }
    public static boolean checkPosition(int x, int y)
    {
        return (x>=0 && x < n && y>=0 && y <m 
        && map[x][y].reachable == true 
        && map[x][y].visited==false);
    }
    public static int bfs()
    {
        //EscapeFromPrison e = new EscapeFromPrison();

        Queue<Point> queue=new LinkedList<Point>();
        Point startPoint = new Point(x0,y0,0);
        map[x0][y0].visited = true;
        queue.add(startPoint);
        int maxSteps = 0;


        while(!queue.isEmpty())
        {
            Point p = queue.poll();
            maxSteps = max(maxSteps, p.step);

            for (int i = 0; i < stepTypes; i++) {

                int nextX = p.x + dx[i];
                int nextY = p.y + dy[i];
                if(checkPosition(nextX, nextY)) 
                // next position is not visited and reachable
                {
                    Point q = new Point(nextX,nextY,p.step +1);
                    map[nextX][nextY].visited = true;
                    queue.add(q);
                }

            }
        }
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if(map[i][j].reachable == true && map[i][j].visited != true)
                {
                    return -1;
                }

            }
        }

        return maxSteps;
    }
    public static void main(String[] args) {

        Scanner sin = new Scanner(System.in);
        while (sin.hasNext()) {
            n = sin.nextInt();
            m = sin.nextInt();

            for (int i = 0; i < n; i++) {
                String dotLine = sin.next(); 
                // java does not support next char method
                for (int j = 0; j < m; j++) {
                    if(dotLine.charAt(j)=='.')
                    {
                        map[i][j].reachable=true;
                    }

                }
            }
            x0 = sin.nextInt();
            y0 = sin.nextInt();

            stepTypes = sin.nextInt();

            for (int i = 0; i < stepTypes; i++) {
                dx[i] = sin.nextInt();
                dy[i] = sin.nextInt();
            }
        }

        int result = bfs();
        System.out.println(result);

    }
}