题目描述
定义一个二维数组N*M（其中2<=N<=10;2<=M<=10），如5 × 5数组下所示：

int maze[5][5] = {

    0, 1, 0, 0, 0,

    0, 1, 0, 1, 0,

    0, 0, 0, 0, 0,

    0, 1, 1, 1, 0,

    0, 0, 0, 1, 0,

};

它表示一个迷宫，其中的1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线。入口点为[0,0],既第一空格是可以走的路。
Input
一个N × M的二维数组，表示一个迷宫。数据保证有唯一解,不考虑有多解的情况，即迷宫只有一条通道。
Output
左上角到右下角的最短路径，格式如样例所示。
Sample Input
0 1 0 0 0
0 1 0 1 0
0 0 0 0 0
0 1 1 1 0
0 0 0 1 0
Sample Output
(0, 0)
(1, 0)
(2, 0)
(2, 1)
(2, 2)
(2, 3)
(2, 4)
(3, 4)
(4, 4)

输入描述:
输入两个整数，分别表示二位数组的行数，列数。再输入相应的数组，其中的1表示墙壁，0表示可以走的路。数据保证有唯一解,不考虑有多解的情况，即迷宫只有一条通道。

输出描述:
左上角到右下角的最短路径，格式如样例所示。

输入例子:
5 5
0 1 0 0 0
0 1 0 1 0
0 0 0 0 0
0 1 1 1 0
0 0 0 1 0

输出例子:
(0,0)
(1,0)
(2,0)
(2,1)
(2,2)
(2,3)
(2,4)
(3,4)
(4,4)

代码

import java.util.Scanner;
import java.util.Stack;


public class Maze {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner sc=new Scanner(System.in);
        while(sc.hasNext())
        {

            int m=sc.nextInt(),n=sc.nextInt();
            int a[][]=new int[m][n];
            for(int i=0;i<m;i++)
                for(int j=0;j<n;j++)
                {
                    a[i][j]=sc.nextInt();
                }       
            leastRoute(m,n,a);
        }
        sc.close();
    }
    public static void leastRoute(int m,int n,int a[][])
    {
        Node start=new Node(0,0);
        Stack<Node> stack=new Stack<Node>();
        stack.push(start);
        int[][] visited = new int[m][n];//标记是否被访问，这个要和Map大小对应
        int[][] dir = {{1, 0}, {0, 1}};//定义两个方向横着走或者竖着走（题目中说只走这两个方向，当前也可以定义多个方向）
        while (!stack.isEmpty()) {
             boolean flag = false;//标记是否找了一个方向
             Node pek = stack.peek();//获取栈顶元素，注意不需要出栈
             if (pek.x == m-1 && pek.y == n-1) {//如果到达目的地则跳出循环
                 break;
             } else {
                 for (int i = 0; i < 2; i++) {//循环两个方向
                     Node nbr = new Node(pek.x + dir[i][0], pek.y + dir[i][1]);//找到当前位置的邻居位置坐标并判断是否合法
                     if (nbr.x >= 0 && nbr.x < m && nbr.y >= 0 && nbr.y < n && a[nbr.x][nbr.y] == 0 && visited[nbr.x][nbr.y] == 0) {//判断邻居节点是否合法
                         stack.push(nbr);//合法将邻居位置加入栈
                         visited[nbr.x][nbr.y] = 1;//并标记该节点已经访问
                         flag = true;//找到了一个方向
                         break;//找到了就停止循环，顺着这个方向一直搜索
                     }
                 }
                 if (flag) {//找到了方向，就不用执行下面的出栈，沿着这个方向一直搜下去
                     continue;
                 }
                 stack.pop();//如果两个方向都不能通过，则出栈。
             }
        }
         Stack<Node> stkRev = new Stack<Node>();//将路径反过来，因为栈中输出的路径是反的
         while (!stack.isEmpty()) {
             stkRev.push(stack.pop());
         }
         while (!stkRev.isEmpty()) {
              System.out.println("(" + stkRev.peek().x + "," + stkRev.peek().y + ")");
             stkRev.pop();
         }
    }

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

    }