package tableroajedrez.caballo;
 
    import java.util.Random;
 
    /**
     *
     * @author aleinshir
     */
    public class Kernel {
 
        private int Tablero[][];                                                        // Tablero de ajedre representado en una matriz
        private static int horizontal[] = new int[] {  2,  1, -1, -2, -2, -1, 1, 2 };                       // Movimientos posibles de manera horizonta
        private static int vertical[] = new int[]      { -1, -2, -2, -1,  1,  2, 2, 1 };                        // Movimientos posibles de manera vertical
        private int movimientos;                                                        // Movimientos realizados
        private boolean aux_mov;                                                        // Auxiliar de prueba
        private int prueba;                                                         // Variable para probar todos los movimientos
        private boolean auxiliar;                                                       // Auxiliar para saber si se soluciono el problema
        private int siguiente_mov;                                                      // Siguiente movimiento que hara el caballo
        private int errores;                                                            // Se asegura que el caballo no este atrapado
        private Random rand;                                                        // Numero aleatorio
        private boolean auxiliar_ex;
        private boolean auxiliar_listo;
        private int numero;
        /**
         * Inicializa el tablero y randomiza la clase "Random".
         */
        public Kernel() {
            this.Tablero = new int[8][8];
            rand = new Random(System.nanoTime());
            construir_array();
        }
 
        /**
         *
         * Clase que inicial el kernel para determina el final del problema.
         *
         * @param posicionH Posicion inicial vertical
         * @param posicionV Posicion inicial vertical
         * @return El tablero ya resuelto
         */
        @SuppressWarnings("empty-statement")
        public int [][] start(int posicionH, int posicionV) {
            do
                auxiliar_listo =  recorrido_completo(posicionH, posicionV);
            while (auxiliar_listo == false);
            return Tablero;
        }
 
        /**
         *
         * @return True si esta completo el recorrido
         */
        private  boolean recorrido_completo(int posicionH, int posicionV) {
 
            auxiliar = true;
            for (movimientos = 1, errores = 0; movimientos <= 64 && auxiliar; movimientos++)    // Ciclo exterior
            {
                aux_mov = true;
                siguiente_mov = rand.nextInt(8);                                        // Determina el proximo movimiento
                for (prueba = 0; prueba < 8 && aux_mov; prueba++, siguiente_mov++, errores++)// Prueba todos los posibles movimientos
                {
 
                    if (siguiente_mov == 8)                                         // Pasa al movimento 0 cuando llega al 8
                        siguiente_mov = 0;
 
                    try
                    {
                        if (Tablero[posicionH + horizontal[siguiente_mov]][posicionV + vertical[siguiente_mov]] == 0)
                        {
                            Tablero[posicionH][posicionV] = movimientos;
 
                            errores = 0;
                            aux_mov = false;
                            posicionV += vertical[siguiente_mov] ;
                            posicionH += horizontal[siguiente_mov] ;
                        }
                    }
                    catch(ArrayIndexOutOfBoundsException e)
                    {
 
                    }
                }
 
                if (errores >= 8)                                                   // Si hay mas de 8 errores corta el recorrido
                    auxiliar =false;
            }
 
            return movimientos >= 64;                                               // True si hizo los 64 movimiento
        }
 
        /**
         *
         * Construye el array dandole 0 (no necesario en java pero es mejor inicializarlo.
         */
        private void construir_array() {
            for (int i = 0; i < 8; i++)
            {
                for (int j = 0; j < 8; j++)
                {
                    Tablero[i][j] = 0;
                }
            }
        }
    }

    #include <stdlib.h>
    #include <stdio.h>
    #include <time.h>
 
    #define TAMANIOV 12                                     // Altura del tablero
    #define TAMANIOH 12                                     // Anchura del tablero
 
    int despliega_tablero(const int tablero[][TAMANIOV]);
    int llamar(int posicionH, int posicionV, int intento);
 
    int main()
    {
        srand(time(NULL));
        int posicionH, posicionV;
        scanf("%d%d", &posicionH, &posicionV);
        posicionH += 2;
        posicionV += 2;
        int i, intento = 0;
        for (i = 0; i == 0;)
        {
            intento++;
            if (llamar(posicionH, posicionV, intento) == 1)
            {
                intento = 0;
            }
        }
        system("pause");
        return 0;
    }
 
    int llamar(int posicionH, int posicionV, int intento)
    {
        int Tablero[TAMANIOH][TAMANIOV] = { 0 };
        int horizontal[8] = { 02, 01, -1, -2, -2, -1, 1, 2 };
        int vertical[8] =   { -1, -2, -2, -1, 01, 02, 2, 1 };
        int movimientos, errorlevel, almacenaH, almacenaV;
        int siguiente, fun;
        for  (movimientos = 1, errorlevel = 0; movimientos != 65;)
        {
             siguiente = rand() % 7;
             for (fun = 0; fun < 8; siguiente++, fun++)
             {
                 if (siguiente == 8)
                     siguiente = 0;
                 if (Tablero[posicionH + horizontal[siguiente]][posicionV + vertical[siguiente]] == 0)
                 {
                     errorlevel = 0;
                     Tablero[posicionH][posicionV] = movimientos;
                     almacenaH = posicionH;
                     almacenaV = posicionV;
                     posicionH += horizontal[siguiente];
                     posicionV += vertical[siguiente];
                     if (posicionH == 0 || posicionH == 1 || posicionV == 0 || posicionV == 1)
                     {
                         Tablero[posicionH][posicionV] = 1;
                         posicionH = almacenaH;
                         posicionV = almacenaV;
                         continue;
                     }
 
                     if (posicionH == 10 || posicionH == 11 || posicionV == 10 || posicionV == 11)
                     {
                         Tablero[posicionH][posicionV] = 1;
                         posicionH = almacenaH;
                         posicionV = almacenaV;
                         continue;
                     }
                     movimientos++;
                     break;
                 }
             }
            errorlevel++;
            if (errorlevel >= 8)
               break;
 
        }
 
        if (movimientos >= 64)
        {
            system("cls");
            despliega_tablero(Tablero);
            printf("movimientos = %d\nintentos = %d\n", movimientos, intento);
            system("pause");
            return 1;
        }
        else
        {
            return 0;
        }
 
 
    }
 
    int despliega_tablero(const int tablero[][TAMANIOV])
    {
         int columna, fila;
         for (columna = 2; columna < 10; columna++)
         {
             for(fila = 2; fila < 10; fila++)
             {
                      if( tablero[columna][fila] == 0)
                          printf("%3s", "0" );
                      if(tablero[columna][fila] != 0)
                          printf("%3d", tablero[columna][fila]);
             }
             printf("\n");
 
         }
         return 0;
    }