Código de Java - Laberinto en java

Imágen de perfil
Val: 86
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

Laberinto en javagráfica de visualizaciones


Java

Publicado el 8 de Junio del 2020 por Adan (10 códigos)
681 visualizaciones desde el 8 de Junio del 2020
Busca el queso desde un punto dado

1.0

Publicado el 8 de Junio del 2020gráfica de visualizaciones de la versión: 1.0
682 visualizaciones desde el 8 de Junio del 2020
estrellaestrellaestrellaestrellaestrella
estrellaestrellaestrellaestrella
estrellaestrellaestrella
estrellaestrella
estrella

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
public class Laberinto{
 
    public int contador = 0;
    public char[][] laberinto={ // dibujamos nuestro laberinto. En este caso, este es el diseño que hemos elegido
        {'#', '#', '#', '#', '#', '#', '#', '#', '#', '#'},
        {'#', ' ', ' ', ' ', '#', ' ', '#', ' ', ' ', '#'},
        {'#', ' ', ' ', ' ', '#', ' ', '#', ' ', '#', '#'},
        {'#', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '#'},
        {'#', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '#'},
        {'#', '#', '#', ' ', ' ', ' ', ' ', ' ', ' ', '#'},
        {'#', ' ', ' ', ' ', ' ', '#', '#', '#', '#', '#'},
        {'#', ' ', ' ', ' ', ' ', ' ', '#', ' ', '#', '#'},
        {'#', ' ', '#', ' ', ' ', ' ', ' ', ' ', ' ', '#'},
        {'#', '#', '#', '#', '#', '#', '#', '#', '#', '#'},
    };
 
    /* ----------------- IMPLEMENTACIÓN DEL ALGORITMO ----------------- */
    public void resuelve(int x, int y){ // permite introducir unas coordenadas (x, y)
        if (paso(x, y)) { // intentará resolver el laberinto en estas coordenadas
            laberinto[x][y] = 'S'; // introduce en las coordenadas (x, y) la entrada
        }
    }
 
    private boolean paso(int x, int y) {
        contador++; // en cada llamada incrementaremos el contador
        if (laberinto[x][y]=='X'){ // si hemos llegado a X quiere decir que hemos encontrado solución
            return true; // luego, el algoritmo termina
        }
        if (laberinto[x][y]=='#'||laberinto[x][y]=='*') { // si llegamos a una pared o al mismo punto,
            return false; // entonces el laberinto no puede resolverse y termina.
        }
        // si no se cumple ninguna de estas dos situaciones, quiere decir que nos encontramos en un
        // caso intermedio, por lo tanto, que empezamos a recorrer o todavía no hemos llegado a nada
        laberinto[x][y]='*'; // marcamos la posición como visitada (si es la primera, en las coordenadas x e y
        boolean result;	     // se coloca S de START)
        result=paso(x, y+1); // intentamos ir hacia la izquierda. Primera llamada recursiva
        if (result) return true; // si el resultado es el final, entonces el algoritmo termina
        result=paso(x-1, y); // intentamos ir hacia arriba. Segunda llamada recursiva
        if (result) return true; // si el resultado es el final, entonces el algoritmo termina
        result=paso(x, y-1); // intentamos ir hacia la izquierda. Tercera llamada recursiva
        if (result) return true; // si el resultado es el final, entonces el algoritmo termina
        result=paso(x+1, y); // intentamos ir hacia abajo. Cuarta llamada recursiva
        if (result) return true; // si el resultado es el final, entonces el algoritmo termina
        // si no hemos encontrado la solución en estos cuatros movimientos, volvemos atrás, aunque hay que
        // considerar que en este punto, todas las llamadas recursivas han finalizado. Si en ninguna de ellas
        // se ha conseguido el éxito, entonces el algoritmo termina y devuelve false.
        laberinto[x][y]=' '; // en el caso de no ser el resultado, desmarcamos el camino
        return false; // vuelta atrás si la solución no se encuentra aquí
    }
 
    private String toString() { // imprimiremos nuestra solución. Debido a que la clase Arrays no tiene implementado
        String salida = "";    // un método toString para arrays bidimensionales, lo programamos a mano
        for (int x=0; x<laberinto.length; x++) { // recorremos filas
            for (int y=0; y<laberinto[x].length; y++) { // recorremos columnas
                output += laberinto[x][y] + " "; // output es nuestra variable que va almacenando los valores a imprimir
            }
            salida += "\n"; // devolvemos esta variable con un salto de línea
        }
        return salida;
    }
 
    /* --------------------- PRUEBA DEL ALGORITMO --------------------- */
    public static void main(String[] args) {
        Laberinto m = new Laberinto(); // construimos un objeto de la clase Laberinto por defecto
        m.laberinto[1][1] = 'X'; // introducimos en este caso, la salida (X) en las coordenadas (1,1)
        m.resuelve(8, 1); // ahora, introducimos la entrada (S) en las coordenadas (8,1) y llamamos al algoritmo
        System.out.println(m); // imprimimos el laberinto ya resuelto (si tiene solución)
        System.out.println("Total de casos recursivos examinados: " + m.contador); // también imprimimos las llamadas recursivas necesarias
    }
 
}



Comentarios sobre la versión: 1.0 (0)


No hay comentarios
 

Comentar la versión: 1.0

Nombre
Correo (no se visualiza en la web)
Valoración
Comentarios...
CerrarCerrar
CerrarCerrar
Cerrar

Tienes que ser un usuario registrado para poder insertar imágenes, archivos y/o videos.

Puedes registrarte o validarte desde aquí.

Codigo
Negrita
Subrayado
Tachado
Cursiva
Insertar enlace
Imagen externa
Emoticon
Tabular
Centrar
Titulo
Linea
Disminuir
Aumentar
Vista preliminar
sonreir
dientes
lengua
guiño
enfadado
confundido
llorar
avergonzado
sorprendido
triste
sol
estrella
jarra
camara
taza de cafe
email
beso
bombilla
amor
mal
bien
Es necesario revisar y aceptar las políticas de privacidad

http://lwp-l.com/s6270