HJ43 迷宫问题

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≤n,m≤10 2≤n,m≤10 ， 输入的内容只包含 0≤val≤1 0≤val≤1
输入描述：

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

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

示例 1

输入：
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
输出：
(0,0)
(1,0)
(2,0)
(2,1)
(2,2)
(2,3)
(2,4)
(3,4)
(4,4)

示例 2

输入：
5 5
0 1 0 0 0
0 1 0 1 0
0 0 0 0 1
0 1 1 1 0
0 0 0 0 0
输出：
(0,0)
(1,0)
(2,0)
(3,0)
(4,0)
(4,1)
(4,2)
(4,3)
(4,4)

说明：
注意：不能斜着走！！

题解

import java.util.Scanner;
import java.util.ArrayList;
import java.util.List;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNext()) { // 注意 while 处理多个 case
            // 输入两个整数，分别表示二维数组的行数，列数。
            // 再输入相应的数组，其中的1表示墙壁，0表示可以走的路。
            // 数据保证有唯一解,不考虑有多解的情况，即迷宫只有一条通道。
            int m = in.nextInt();// m 行
            int n = in.nextInt();// n 列
            // 数组 maze
            int [][] maze = new int[m][n];
            for (int i = 0; i < m; i++) {
                for (int j = 0; j < n; j++) {
                    maze[i][j] = in.nextInt();
                }
            }
            // 它表示一个迷宫，其中的1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走
            // 要求编程序找出从左上角到右下角的路线。入口点为[0,0],既第一格是可以走的路。
            // 只有一一条路径
            List<Pos> path = new ArrayList<>();

            // DFS 搜索路径
            dfs(maze, 0, 0, path);

            // 输出结果
            for (Pos p : path) {
                System.out.println("(" + p.x + "," + p.y + ")");
            }

        }
    }
    public static boolean dfs(int[][] maze, int x, int y, List<Pos> path) {
        // DFS 搜索路径
        path.add(new Pos(x, y));
        maze[x][y] = 1;

        // 终止条件
        if (x + 1 == maze.length && y + 1 == maze[0].length) {
            return true;
        }

        // 向下走
        // 不超出矩阵 点不是墙 1
        if (x + 1 < maze.length && maze[x + 1][y] == 0) {
            if (dfs(maze, x + 1, y, path)) {
                return true;
            }
        }
        // 向上走
        if (x - 1 > -1 && maze[x - 1][y] == 0) {
            if (dfs(maze, x - 1, y, path)) {
                return true;
            }
        }
        // 向左走
        if (y - 1 > -1 && maze[x][y - 1] == 0) {
            if (dfs(maze, x, y - 1, path)) {
                return true;
            }
        }
        // 向右走
        if (y + 1 < maze[0].length && maze[x][y + 1] == 0) {
            if (dfs(maze, x, y + 1, path)) {
                return true;
            }
        }

        // 回溯
        path.remove(path.size() - 1);
        maze[x][y] = 0;
        // 返回false
        return false;
    }
}
// 坐标类
class Pos {
    int x;
    int y;;
    public Pos(int x, int y) {
        this.x = x;
        this.y = y;
    }
}