经典笔试迷宫、格子那种问题，以前一直懒得做这种题，终于笔试碰到了，只过了0.18，赶紧补一下。

牛客：

https://www.nowcoder.com/practice/cf24906056f4488c9ddb132f317e03bc?tpId=37&&tqId=21266&rp=1&ru=/activity/oj&qru=/ta/huawei/question-ranking

定义一个二维数组N*M（其中2<=N<=10;2<=M<=10），它表示一个迷宫，其中的1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线。入口点为[0,0],既第一空格是可以走的路。

Input

3 3     //  n   m

0 1 1   //格子数组
0 0 0 
1 1 0 

一个N × M的二维数组，表示一个迷宫。数据保证有唯一解,不考虑有多解的情况，即迷宫只有一条通道。

Output

(0,0)
(1,0)
(1,1)
(1,2)
(2,2)

思路：

1、首相想到递归，递归的结束条件就是到达到目标节点的附近，使用keda()这个函数实现的

2、递归的话，需要对节点的上下左右四个节点都做判断，判断是不是已经遍历过了，判断是不是可以走的格子。

3、已经遍历过得节点错在了队列中，也可以存在栈里，但是最后要打印整个遍历的顺序，所以选择了用队列，队列使用要注意2个容易出错的问题

    a、最终打印结果时，不要使用队列的size作为判断条件，移除元素时，队列长度会改变。

    b、递归时，在队列中的节点不可达时，要把最后的元素删除，不是出队，是队尾。如果用的栈就直接弹栈就好了

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayDeque;
import java.util.Queue;

class Node {
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Node)) return false;

        Node node = (Node) o;

        if (x != node.x) return false;
        return y == node.y;
    }


    int x;
    int y;

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }

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


public class Main2 {
    static Queue<Node> queue = new ArrayDeque<>();

    public static void main(String[] args) throws IOException {
        BufferedReader rd = new BufferedReader(new InputStreamReader(System.in));
        String str = null;
        while ( (str=rd.readLine())!=null) {

            String[] nums = str.split(" ");
            int n = Integer.parseInt(nums[0]);
            int m = Integer.parseInt(nums[1]);
            char[][] arr = new char[n][m];
            Node gongzhu = null;
            Node wangzi = null;
            for (int i = 0; i < n; i++) {
                String[] hang = rd.readLine().split(" ");
                for (int j = 0; j < m; j++) {
                    arr[i][j] = hang[j].charAt(0);
//                    if(hang[j]=='S'){
//                        wangzi = new Node(i,j);
//                    }
//                    if(hang[j]=='E'){
//                        gongzhu = new Node(i,j);
//                    }
                }
            }
            wangzi = new Node(0, 0);
            gongzhu = new Node(n-1, m-1);
            boolean res = dfs(arr, wangzi, gongzhu);

            int len = queue.size();
            //stack.size是活动的，pop元素的时候，size会减小，不能把他当做循环判断条件
            for (int i = 0; i < len; i++) {
                Node node = queue.poll();
                System.out.println("(" + node.getX() + "," + node.getY() + ")");
            }

        }
    }

    private static boolean dfs(char[][] arr, Node wangzi, Node gongzhu) {
        queue.offer(wangzi);
        //wangzi也表是当前所在位置
        boolean res1 = false;
        boolean res2 = false;
        boolean res3 = false;
        boolean res4 = false;

       if(keda(arr,wangzi,gongzhu)) {
           return true;
       }
       else {
            Node shang = new Node(wangzi.getX(), wangzi.getY() + 1);
            Node xia = new Node(wangzi.getX(), wangzi.getY() - 1);
            Node zuo = new Node(wangzi.getX() - 1, wangzi.getY());
            Node you = new Node(wangzi.getX() + 1, wangzi.getY());
            if (feifa(shang, arr)) {

                res1 = dfs(arr, shang, gongzhu);

            }
            if (res1)
                return res1;

            if (feifa(zuo, arr)) {

                res2 = dfs(arr, zuo, gongzhu);

            }
            if (res2)
                return res2;
            if (feifa(xia, arr)) {

                res3 = dfs(arr, xia, gongzhu);

            }
            if (res3)
                return res3;
            if (feifa(you, arr)) {

                res4 = dfs(arr, you, gongzhu);

            }
        }
        boolean res = res1 || res2 || res3 || res4;
        if (!res) {
            queue.remove(wangzi);
        }
        return res;
    }

    private static boolean keda(char[][] arr, Node wangzi, Node gongzhu) {
        if ((wangzi.getX() == gongzhu.getX()) && (Math.abs(wangzi.getY() - gongzhu.getY()) == 1)) {
            queue.offer(gongzhu);
            return true;
        }
        if ((wangzi.getY() == gongzhu.getY()) && (Math.abs(wangzi.getX() - gongzhu.getX()) == 1)) {
            queue.offer(gongzhu);
            return true;
        }
        return false;
    }

    private static boolean feifa(Node node, char[][] arr) {
        if (queue.contains(node)) {
            return false;
        }
        if (!(node.getX() >= 0 && node.getX() < arr.length)) {
            return false;
        }
        if (!(node.getY() >= 0 && node.getY() < arr[0].length)) {
            return false;
        }
        if (arr[node.getX()][node.getY()] == '1') {
            return false;
        }
        return true;
    }

    private static boolean keda(Node wangzi, Node gongzhu) {
        if ((wangzi.getX() == gongzhu.getX()) && (Math.abs(wangzi.getY() - gongzhu.getY()) == 1)) {
            return true;
        }
        if ((wangzi.getY() == gongzhu.getY()) && (Math.abs(wangzi.getX() - gongzhu.getX()) == 1)) {
            return true;
        }
        return false;
    }


}