Java 递归实现迷宫出逃小游戏

一、规则

• 数字含义

  0 - 路; 1 - 墙; 2 - 通路; 3 - 死路

• 寻路策略

  向下 --> 向右 --> 向上 --> 向左

二、代码实现

public class MyClass {
    public static void main(String[] args){
        //迷宫地图，初始为 8 行 7 列
        //0 - 路; 1 - 墙; 2 - 通路; 3 - 死路
        int[][] map = {{1, 1, 1, 1, 1, 1, 1},
                       {1, 0, 0, 0, 0, 0, 1},
                       {1, 0, 0, 0, 0, 0, 1},
                       {1, 1, 1, 0, 0, 0, 1},
                       {1, 0, 0, 0, 0, 0, 1},
                       {1, 0, 0, 0, 1, 0, 1},
                       {1, 0, 0, 0, 1, 0, 1},
                       {1, 1, 1, 1, 1, 1, 1}};
        //起始坐标
        int x = 4, y = 3;

        //是否走得通
        System.out.println("迷宫是否走得通：" + findWay(map, x, y));

        //打印迷宫路线
        System.out.println("迷宫路线如下：");
        for (int i = 0; i < 8; i++) {
            for (int j = 0; j < 7; j++) {
                System.out.printf(map[i][j] + " ");
            }
            System.out.println();
        }
    }

    //递归
    public static boolean findWay(int[][] map, int x, int y) {
        //终点，设置为 map[6][5]
        if (map[6][5] == 2) {
            return true;
        } else {
            //边界，无法继续前进
            if (x < 1 || x > 6 || y < 1 || y > 5 || map[x][y] != 0) {
                return false;
            }

            //假定本格走得通
            map[x][y] = 2;

            //判断是否走得通
            //向下 --> 向右 --> 向上 --> 向左
            if (findWay(map, x + 1, y)) {
                return true;
            } else if (findWay(map, x, y + 1)) {
                return true;
            } else if (findWay(map, x - 1, y)) {
                return true;
            } else if (findWay(map, x, y - 1)) {
                return true;
            } else {
                //走不通则设为死路
                map[x][y] = 3;
                return false;
            }
        }
    }

}

• 时间复杂度：在最坏情况下，每个格子都需要被访问一次。在每个格子上，递归函数会尝试向四个方向进行搜索。因此，总的时间复杂度为 O(4^N*M)。这是因为在最坏情况下，递归函数的深度为 N*M，每层递归有 4 个分支（四个方向）。
• 空间复杂度：递归函数的空间复杂度取决于递归调用的深度。在最坏情况下，递归深度为 N*M，因此空间复杂度为 O(N*M)。这是因为每次递归调用都会在栈上分配一些空间来存储参数、局部变量和返回地址。

三、运行结果

迷宫是否走得通：true
迷宫路线如下：
1 1 1 1 1 1 1 
1 0 0 0 0 0 1
1 0 0 0 0 0 1
1 1 1 0 0 0 1
1 3 3 2 2 2 1
1 3 3 3 1 2 1
1 3 3 3 1 2 1
1 1 1 1 1 1 1