C/Visual C - Movimiento del caballo

 
Vista:

Movimiento del caballo

Publicado por clauido (37 intervenciones) el 08/05/2001 21:55:28
Alguien sabe como hacer un algorítmo recursivo para que con los movimientos del caballo de ajedrez se pueda recorrer todo el
tablero sin pasar + de 1 vez por cada casilla, pero recorriendo ¨todo el tablero¨?
Desde ya gracias
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder
Imágen de perfil de Alejandro

Recorrido del tablero de ajedrez con movimientos del caballo sin repetir casillas

Publicado por Alejandro (913 intervenciones) el 24/09/2024 20:31:58
Aquí tienes un ejemplo de un algoritmo recursivo en C++ para recorrer todo el tablero de ajedrez utilizando los movimientos del caballo sin pasar más de una vez por cada casilla:

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
#include <iostream>
#include <vector>
 
const int N = 8; // Tamaño del tablero de ajedrez
 
// Estructura para representar una casilla del tablero
struct Casilla {
    int x;
    int y;
};
 
// Función para verificar si una casilla está dentro del tablero
bool esValida(int x, int y) {
    return (x >= 0 && x < N && y >= 0 && y < N);
}
 
// Función recursiva para recorrer el tablero utilizando los movimientos del caballo
void recorrerTablero(int x, int y, int movimiento, std::vector<std::vector<int>>& tablero, std::vector<Casilla>& recorrido) {
    // Marcar la casilla actual como visitada
    tablero[x][y] = movimiento;
    recorrido.push_back({x, y});
 
    // Verificar si se han visitado todas las casillas del tablero
    if (movimiento == N * N) {
        // Imprimir el recorrido
        for (const auto& casilla : recorrido) {
            std::cout << "(" << casilla.x << ", " << casilla.y << ") ";
        }
        std::cout << std::endl;
    } else {
        // Generar los posibles movimientos del caballo
        int movimientosX[] = {2, 1, -1, -2, -2, -1, 1, 2};
        int movimientosY[] = {1, 2, 2, 1, -1, -2, -2, -1};
 
        // Intentar realizar cada movimiento
        for (int i = 0; i < 8; i++) {
            int nuevaX = x + movimientosX[i];
            int nuevaY = y + movimientosY[i];
 
            // Verificar si el movimiento es válido y la casilla no ha sido visitada
            if (esValida(nuevaX, nuevaY) && tablero[nuevaX][nuevaY] == 0) {
                recorrerTablero(nuevaX, nuevaY, movimiento + 1, tablero, recorrido);
            }
        }
    }
 
    // Desmarcar la casilla actual como visitada
    tablero[x][y] = 0;
    recorrido.pop_back();
}
 
int main() {
    std::vector<std::vector<int>> tablero(N, std::vector<int>(N, 0)); // Inicializar el tablero con ceros
    std::vector<Casilla> recorrido; // Vector para almacenar el recorrido del caballo
 
    // Iniciar el recorrido desde la casilla (0, 0)
    recorrerTablero(0, 0, 1, tablero, recorrido);
 
    return 0;
}

En este algoritmo, utilizamos la técnica de "backtracking" para explorar todas las posibles combinaciones de movimientos del caballo en el tablero. La función `recorrerTablero` realiza un movimiento del caballo a una casilla adyacente válida y luego llama recursivamente a sí misma para continuar el recorrido. Si se han visitado todas las casillas del tablero, se imprime el recorrido.

Espero que este algoritmo te sea útil para recorrer todo el tablero de ajedrez utilizando los movimientos del caballo sin pasar más de una vez por cada casilla. ¡Buena suerte, Clauido!
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar