Java implementa recursivamente el juego de escape del laberinto

1. Reglas

• significado digital

  0 - camino; 1 - pared; 2 - pasaje; 3 - callejón sin salida

• Estrategia de búsqueda de caminos

  Abajo --> Derecha --> Arriba --> Izquierda

2. Implementación del código

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;
            }
        }
    }

}

• Complejidad del tiempo: en el peor de los casos, cada cuadrícula debe visitarse una vez. En cada cuadrícula, la función recursiva intenta buscar en cuatro direcciones. Por lo tanto, la complejidad del tiempo total es O(4^N*M). Esto se debe a que, en el peor de los casos, la profundidad de la función recursiva es N*My cada nivel de recursividad tiene 4ramas (cuatro direcciones).
• Complejidad espacial: la complejidad espacial de una función recursiva depende de la profundidad de las llamadas recursivas. En el peor de los casos, la profundidad de recursividad es N*M, por lo que la complejidad del espacio es O(N*M). Esto se debe a que cada llamada recursiva asigna algo de espacio en la pila para almacenar parámetros, variables locales y direcciones de retorno.

3. Resultados de ejecución

迷宫是否走得通：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