Hola estoy realizando el ejercicio del libro de deitel&deitel llamado el recorrido del caballo se supone que tengo que simular un tablero de ajedrez y y simular los movimientos de un caballo y pasar por cada casilla sólo una vez.

-El modo "manual" ya esta listo.
-Cree una función que me permite saber desde cuantas posiciones es accesible un cada cuadro.
-Cree un modo automático que selecciona la casilla accesible en este turno pero menos accesible comparada con las demás disponibles.
-También cree un array marca del mismo tamaño del tablero para saber que paso fue x movimiento.

Lo que necesitó ahora es crear una clase de historial que le permita al programa devolverse un paso y cuando se quede sin opciones devolverse 2 y así. Alguna idea?

Extra:

Otra cosa llevó más o menos 500 líneas de código... Creo que me estoy enredando mucho para hacer cosas simples o es un número normal? Estimen aproximadamente cuantas les llevaría a ustedes.

Para ese tipo de problemas se suele emplear el algoritmo BackTracking que no es más que un algoritmo recursivo de búsqueda que explora todas los caminos que puedan conducir a la solución del problema aunque a veces el tiempo que el algoritmo demora en encontrar la solución es mucho por lo que se suele utilizar heuristicas que son como atajos para reducir el tiempo de búsqueda( para el problema del recorrido del caballo no se puede sólo con el algoritmo BackTracking porque se demora mucho tiempo aunque de todas formas se puede utilizar).

Cuando entiendas el funcionamiento del algoritmo por ejemplo puedes hacer un tablero más pequeño para que puedas ver si te funciona el algoritmo para después ampliar el tablero y probar con heuristicas( una que conozco es explorar las casillas desde donde se tengan menos casillas para saltar)


Pues sólo el procedimiento del algoritmo para este problema lleva no más de 20 lineas. Para saber si la casilla en donde se quiere saltar está disponible yo me suelo llevar otras 2 lineas utilizando el método de representación 0x88 que se suele utilizar mucho en los motores de ajedrez.

Un saludo.

No sé si funciona porque no lo he compilado;

bool Recorrido( int casilla_actual, int n_saltos ){ 
 
	tablero[casilla_actual] = n_saltos;
 
	if( n_saltos == 64 ) return true;
 
	else {
		GenerarCasillasDisponibles();
		Para cada Casilla Disponible hacer: 
			if( Recorrido(casilla_nueva,n_saltos+1) ) return true;
	}
 
	tablero[casilla_actual] = 0;
 
	return false;
 
}

Lo acabo de hacer en 5 minutos pero no sé si funciona, espero que si entiendas la idea aunque sea, iré a dormir y mañana lo continuo.

Es el algoritmo que te habia mencionado, la solución en teoria se iría guardando en el arreglo 'tablero' con la variable 'n_saltos' y termina cuando n_saltos es igual a 64 es decir, cuando se ha visitado todas las casillas y por lo tanto se ha encontrado la solución. El tablero puede ser unidimensional, bidimensional o como sea pero el algoritmo sería el mismo sólo que tendrías que ordenar los movimientos del caballo con la heuristica que ya comentaste( visitar primero las casillas que aparenten solucionar más rápido el problema).


Vale, intenta solucionarlo a tu manera así se aprende más. La verdad yo lo intentaría hacer incluso durante semanas si es necesario