HJ43 迷宫问题 —— 华为机试练习题

一、题目

描述
定义一个二维数组 N*M ，如 5 × 5 数组下所示：

int maze[5][5] = {
0, 1, 0, 0, 0,
0, 1, 1, 1, 0,
0, 0, 0, 0, 0,
0, 1, 1, 1, 0,
0, 0, 0, 1, 0,
};

它表示一个迷宫，其中的1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的路线。入口点为[0,0],既第一格是可以走的路。

数据范围： 2 \le n,m \le 10 \2≤n,m≤10 ， 输入的内容只包含 0 \le val \le 1 \0≤val≤1

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

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

二、代码

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

public class Main {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while (in.hasNext()) {
            int n = in.nextInt(); // 行数
            int m = in.nextInt(); // 列数
            int[][] maze = new int[n][m];
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < m; j++) {
                    maze[i][j] = in.nextInt();
                }
            }

            int[][] visited = new int[n][m];
            Stack<Node> stack = new Stack<>();
            Node start = new Node(0, 0);// 起点
            Node end = new Node(n - 1, m - 1);// 终点
            int[][] dir = {{1, 0}, {0, 1},{-1,0},{0,-1}};
            visited[start.x][start.y] = 1;
            stack.push(start);

            while (!stack.isEmpty()) {
                Node peek = stack.peek();
                if (peek.x == end.x && peek.y == end.y) {
                    break;
                }
                boolean flag = false;
                for (int i = 0; i < 4; i++) {
                    Node temp = new Node(peek.x + dir[i][0], peek.y + dir[i][1]);
                    if (temp.x >= 0 && temp.x < n && temp.y >= 0 && temp.y < m && visited[temp.x][temp.y] == 0 && maze[temp.x][temp.y] == 0) {
                        stack.push(temp);
                        flag = true;
                        visited[temp.x][temp.y] = 1;
                        break;
                    }
                }
                if (flag) {
                    continue;
                }
                stack.pop();
            }

            Stack<Node> preStack = new Stack<>();
            while (!stack.isEmpty()) {
                preStack.push(stack.pop());
            }
            while (!preStack.isEmpty()) {
                System.out.println("(" + preStack.peek().x + "," + preStack.peek().y + ")");
                preStack.pop();
            }
        }
    }
}

class Node {
    int x, y;

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