迷宫问题(回溯、栈)_定义一个二维数组 n*m,如 5 x 5 数组下所示: tint maze[5][5] = 0, 1

描述
定义一个二维数组 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， 输入的内容只包含 0 <= val <=1

输入描述：

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

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

输入：
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)

代码：

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

/**
 * @author gufusheng
 * @time 2021/11/17 20:05
 */
public class HJ43 {

    private static int[][] graph;
    private static int m,n;

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()) {
            n = scanner.nextInt();
            m = scanner.nextInt();

            graph = new int[n][m];
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < m; j++) {
                    graph[i][j] = scanner.nextInt();
                }
            }

            Stack<Point> rout = new Stack<>();
            setWay(0,0, rout);

            System.out.println("显示染色后的通路");
            for (int i = 0; i < n; i++) {
                System.out.printf(Arrays.toString(graph[i]));
                System.out.println();
            }

            System.out.println("路径输出");
            for (int i = 0; i < rout.size(); i++) {
                System.out.println("(" + rout.get(i).x + "," + rout.get(i).y + ")");
            }
        }
    }

    /**
     * graph[i][j] = 2,表示可以通过
     */
    public static boolean setWay(int i, int j, Stack<Point> rout) {
        if (graph[n-1][m-1] == 2) {
            return true;
        }
        if ( i >= 0 && i < n && j>= 0 && j < m && graph[i][j] == 0) {
            graph[i][j] = 2; // 假定该点可以走
            rout.push(new Point(i,j));

            if (setWay(i+1, j, rout)) {
                graph[i][j] = 2;
                return true;
            } else if (setWay(i, j+1, rout)) {
                graph[i][j] = 2;
                return true;
            }else if (setWay(i-1, j, rout)) {
                graph[i][j] = 2;
                return true;
            }else if (setWay(i, j-1, rout)) {
                graph[i][j] = 2;
                return true;
            } else {
                graph[i][j] = 1;
                rout.pop();
                return false;
            }
        } else {
            return false;
        }
    }
}

class Point {
    int x;
    int y;

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86