C Tá difícil terminar o exercício

[Cristina2000]

Exercício 6.24 Como programar em C – H.M. Deitel  e P.J.Deitel
.
Eu estou com problemas em resolver o exercício abaixo. Ele já está quase funcionando, mas  tem algo que não está funcionando direito com relação à um vetor. Eu acumulo algumas posições para comparar qual a mais adequada para o próximo passo a ser dado. O programa seleciona estes movimentos os utiliza. E então eu tenho que zerar o vetor. Já fiz  isso em três lugares diferentes e o vetor não “zera” de modo nenhum. Como eu tenho problemas de um cara que invade o meu computador e altera o meu IDE. Eu não sei  se é algo que eu estou fazendo errado, ou se é “zoeira” desse cara que me persegue. 
Se alguém puder tentar me ajudar, eu agradeço.
O programa está todo comentado e também está com vários  “marcadores”   que eu fiz procurando  erros.
Outra coisa. O programa é para ser feito utilizando somente vetores.  Nesta parte do livro ainda não se chegou  em  struct ,filas ou ponteiros.
Eu fiz um programa em um bloco único. Assim que ele estiver rodando eu o divido em funções. 
Desde já os meus agradecimentos. 
.
Enunciado:
Um dos problemas mais interessantes para os  fãs do jogo de xadrez é o problema do Passeio do Cavalo proposto originalmente pelo matemático Euler.
A questão é esta: a peça do jogo de xadrez  chamada cavalo pode mover ao longo de um tabuleiro vazio e passar uma única vez em cada uma das 64 casas.
O cavalo faz movimentos em formato de  ”L” (percorre duas casas em  uma direção  e uma no sentido perpendicular às duas primeiras. Dessa forma de uma casa no meio do tabuleiro, o cavalo pode fazer 8 movimentos diferentes, ou seja, ele pode se movimentar:
Movimento 1. Mover 2 posições à direita e 1 para baixo;
Movimento 2.  Mover 1 posição à direita e 2 para baixo;
Movimento 3. Mover 2 posições à direita e 1 para cima;
Movimento 4. Mover 1 posição à direita e 2 para cima;
Desenvolva um programa que moverá o cavalo pelo tabuleiro de xadrez. O tabuleiro em si é representado  pelo array bidimensional  8-por-8 tabuleiro.
Cada um dos quadrados(casas) é inicializado com o valor zero.
Utilize um contador que varie de 1 à 64.
Lembre-se de testar cada movimento potencial para se certificar de que o cavalo não está saindo do tabuleiro.
Os quadrados estão classificados de acordo com a sua acessibilidade pelo vetor tabuleiro2  onde deve-se mover o cavalo(dentro dos movimentos  em forma de “L”) para o quadrado que seja mais inacessível. Os números  do vetor tabuleiro2 indicam a partir de quantos quadrados um determinado quadrado pode ser acessado.
O cavalo deve se mover para o quadrado com menor número de acessibilidade. Em caso de empate o   cavalo pode se mover para qualquer um dos quadrados que empataram. 
Até aqui eu fiz.
.
Só que a continuação do exercício pede que agora o exercício seja modificado de modo a que  quando houver um empate entre  dois ou mais quadrados a escolha seja feita verificando os quadrados que podem ser alcançados a partir dos quadrados empatados. O programa deve fazer o movimento do cavalo para o quadrado para o qual o próximo movimento levar ao quadrado com menor número de acessibilidade. 
Por exemplo:
Eu preenchi um quadrado e no próximo movimento existem duas posições que eu posso acessar de onde estou. O programa deve verificar qual das duas posições possui um número menor  no vetor tabuleiro2. 

.

#include <stdio.h>
#include <stdlib.h>
#include <locale.h>
#include <windows.h>
#define TAMANHO 8
void imprime(int a[TAMANHO][TAMANHO]);

int main()
{
    int i,j,tabuleiro[TAMANHO][TAMANHO]={0};
    static int x2,y2,num1=0,num2=0,movimento2=1,cont30=2,cont4=0,cont6=0;
    static int x=0,y=0,cont=0,cont2=0,cont3=0,cont20=2,movimento=1,vetor[TAMANHO][TAMANHO]={0};
    static int tabuleiro2[TAMANHO][TAMANHO]= {{2,3,4,4,4,4,3,2},
                                              {3,4,6,6,6,6,4,3},
                                              {4,6,8,8,8,8,6,4},
                                              {4,6,8,8,8,8,6,4},
                                              {4,6,8,8,8,8,6,4},
                                              {4,6,8,8,8,8,6,4},
                                              {3,4,6,6,6,6,4,3},
                                              {2,3,4,4,4,4,3,2}};
    setlocale(LC_ALL,"");
    while(cont<64){
        printf(" 1. Mover 2 posições à direita e 1 para baixo\n");
        printf(" 2. Mover 1 posição à direita e 2 para baixo\n");
        printf(" 3. Mover 2 posições à direita e 1 para cima\n");
        printf(" 4. Mover 1 posição à direita e 2 para cima\n");
        printf(" 5. Mover 2 posições à esquerda e 1 para cima\n");
        printf(" 6. Mover 2 posições à esquerda e 1 para baixo\n");
        printf(" 7. Mover 1 posição à esquerda e 2 para cima\n");
        printf(" 8. Mover 1 posição à esquerda e 2 para baixo\n");

        if(movimento==1){
            x=x+1;                  //Testa  o movimento 1
            if(x>=TAMANHO)          //Verifica se a linha
                cont2++;            //pertence ao tabuleiro
            y=y+2;
            printf("1. x= %d  y= %d\n",x,y);
            if(y>=TAMANHO)       //Verifica se a coluna
                cont2++;        //pertence ao tabuleiro
            if(cont2==0 && tabuleiro[x][y]==0){//Verifica se a posição está vazia
                if(tabuleiro2[x][y]==cont20){ //verifica se nessa posição está
                    vetor[x][y]=cont20;       //o menor valor do vetor
                    tabuleiro[x][y]=cont;   //Adiciona este movimento ao vetor
                    cont++;
                    num1=x;            //cont20 ´começa do menos valor
                    num2=y;            //que é 2 e vai até 8
                    cont3++;           // que são as posições do tabuleiro2
                }                      //cont3 conta quantas posições ue servem
            }                           //foram encontradas
            x=x-1;          //x w y retornam ao valor anterior
            y=y-2;          //para continuar a busca
            cont2=0;
            movimento++;
            printf("1. x= %d  y= %d\n",x,y);
            printf("cont20= %d\n",cont20);
            printf("cont3= %d\n\n",cont3);
        }

        if(movimento==2){
            x=x+2;
            if(x>=TAMANHO)
                cont2++;
            y=y+1;
            printf("2. x= %d  y= %d\n",x,y);
            if(y>=TAMANHO)
                cont2++;
            if(cont2==0 && tabuleiro[x][y]==0){
                if(tabuleiro2[x][y]==cont20){
                    vetor[x][y]=cont20;
                    tabuleiro[x][y]=cont;
                    cont++;
                    num1=x;
                    num2=y;
                    cont3++;
                }
            }
            x=x-2;
            y=y-1;
            cont2=0;
            movimento++;
            printf("2. x= %d  y= %d\n",x,y);
            printf("cont20= %d\n",cont20);
            printf("cont3= %d\n\n",cont3);
        }

        if(movimento==3){
            x=x-1;
            if(x<0)
                cont2++;
            y=y+2;
            printf("3. x= %d  y= %d\n",x,y);
            if(y>=TAMANHO)
                cont2++;
            if(cont2==0 && tabuleiro[x][y]==0){
                if(tabuleiro2[x][y]==cont20){
                    vetor[x][y]=cont20;
                    tabuleiro[x][y]=cont;
                    cont++;
                    num1=x;
                    num2=y;
                    cont3++;
                }
            }
            x=x+1;
            y=y-2;
            cont2=0;
            movimento++;
            printf("3. x= %d  y= %d\n",x,y);
            printf("cont20= %d\n",cont20);
            printf("cont3= %d\n\n",cont3);
        }

        if(movimento==4){
            x=x-2;
            if(x<0)
                cont2++;
            y=y+1;
            printf("4. x= %d  y= %d\n",x,y);
            if(y>=TAMANHO)
                cont2++;
            if(cont2==0 && tabuleiro[x][y]==0){
                if(tabuleiro2[x][y]==cont20){
                    vetor[x][y]=cont20;
                    tabuleiro[x][y]=cont;
                    cont++;
                    num1=x;
                    num2=y;
                    cont3++;
                }
            }
            x=x+2;
            y=y-1;
            cont2=0;
            movimento++;
            printf("4. x= %d  y= %d\n",x,y);
            printf("cont20= %d\n",cont20);
            printf("cont3= %d\n\n",cont3);
        }

        if(movimento==5){
            x=x-1;
            if(x<0)
                cont2++;
            y=y-2;
            printf("5. x= %d  y= %d\n",x,y);
            if(y<0)
                cont2++;
            if(cont2==0 && tabuleiro[x][y]==0){
                if(tabuleiro2[x][y]==cont20){
                    vetor[x][y]=cont20;
                    tabuleiro[x][y]=cont;
                    cont++;
                    num1=x;
                    num2=y;
                    cont3++;
                }
            }
            x=x+1;
            y=y+2;
            cont2=0;
            movimento++;
            printf("5. x= %d  y= %d\n",x,y);
            printf("cont20= %d\n",cont20);
            printf("cont3= %d\n\n",cont3);
        }

        if(movimento==6){
            x=x+1;
            if(x>=TAMANHO)
                cont2++;
            y=y-2;
            printf("6. x= %d  y= %d\n",x,y);
            if(y<0)
                cont2++;
            if(cont2==0 && tabuleiro[x][y]==0){
                if(tabuleiro2[x][y]==cont20){
                    vetor[x][y]=cont20;
                    tabuleiro[x][y]=cont;
                    cont++;
                    num1=x;
                    num2=y;
                    cont3++;
                }
            }
            x=x-1;
            y=y+2;
            cont2=0;
            movimento++;
            printf("6. x= %d  y= %d\n",x,y);
            printf("cont20= %d\n",cont20);
            printf("cont3= %d\n\n",cont3);
        }

        if(movimento==7){
            x=x-2;
            if(x<0)
                cont2++;
            y=y-1;
            printf("7. x= %d  y= %d\n",x,y);
            if(y<0)
                cont2++;
            if(cont2==0 && tabuleiro[x][y]==0){
                if(tabuleiro2[x][y]==cont20){
                    vetor[x][y]=cont20;
                    tabuleiro[x][y]=cont;
                    cont++;
                    num1=x;
                    num2=y;
                    cont3++;
                }
            }
            x=x+2;
            y=y+1;
            cont2=0;
            movimento++;
            printf("7. x= %d  y= %d\n",x,y);
            printf("cont20= %d\n",cont20);
            printf("cont3= %d\n\n",cont3);
        }

        if(movimento==8){
            x=x+2;
            if(x>=TAMANHO)
                cont2++;
            y=y-1;
            printf("8. x= %d  y= %d\n",x,y);
            if(y<0)
                cont2++;
            if(cont2==0 && tabuleiro[x][y]==0){
                if(tabuleiro2[x][y]==cont20){
                    vetor[x][y]=cont20;
                    tabuleiro[x][y]=cont;
                    cont++;
                    num1=x;
                    num2=y;
                    cont3++;
                }
            }
            x=x-2;
            y=y+1;
            cont2=0;
            movimento++;
            printf("8. x= %d  y= %d\n",x,y);
            printf("cont20= %d\n",cont20);
            printf("cont3= %d\n\n",cont3);
        }


        if(cont3==0){
            if(cont20==8)       //Se cont3==0 significa que
                cont20=2;       //nenhuma posição é igual a
            else                //cont20.
                cont20++;
        }
        if(cont3==1){
            x=num1;
            y=num2;
            for(i=0;i<TAMANHO;i++){
                for(j=0;j<TAMANHO;j++){
                    vetor[x][y]=0;
                }
            }
            cont20=2;
            cont3=0;
        }
        if(cont3>1){
            //cont=cont-cont3+1;
            printf("Maior que 1\n");
            movimento2=1;
            while(cont30<8){
                for(i=0;i<TAMANHO;i++){
                    Sleep(100);
                    for(j=0;j<TAMANHO;j++){
                        cont6=0;
                        Sleep(100);
                        //*********
                        printf("\n\n*UM\n\n\n");
                        //*******
                        Sleep(100);
                        if(vetor[i][j]!=0){
                            movimento2=1;

                                printf("\n\nDOIS\n\n\n");
                                Sleep(100);

                            printf("vetor[%d][%d]= %d\n",i,j,vetor[i][j]);
                            printf("movimento2= %d\n",movimento2);
                            x2=i;
                            y2=j;
                             if(movimento2==1){
                                x2=x2+1;
                                if(x2>=TAMANHO)
                                    cont4++;
                                y2=y2+2;
                                printf("1. x2= %d  y2= %d\n",x2,y2);
                                if(y2>=TAMANHO)
                                    cont4++;
                                if(cont4==0 && tabuleiro[x2][y2]==0){
                                    if(tabuleiro2[x2][y2]==cont30){
                                        tabuleiro[x2][y2]=cont;
                                        cont++;
                                        num1=x2;
                                        num2=y2;
                                        x=i;
                                        y=j;
                                        cont6++;
                                        cont30=2;
                                        printf("\n\nAqui eu zero o  vetor nessa posição.\n");
                                        vetor[x2][y2]=0;
                                        printf("vetor = %d\n",vetor[x2][y2]);
                                        printf("Só que ao imprimir o vetor (abaixo) ele não aparece zerado\n");
                                        printf("Pelo menos no meu IDE ele não aparece zerado.\n\n");
                                        imprime(vetor);
                                        break;
                                    }
                                }
                                x2=x2-1;
                                y2=y2-2;
                                cont4=0;
                                movimento2++;
                                printf("1. x2= %d  y2= %d\n",x2,y2);
                                printf("cont30= %d\n",cont30);
                                printf("\n\nUm um\n\n\n");
                            }

                            if(movimento2==2){
                                x2=x2+2;
                                if(x2>=TAMANHO)
                                    cont4++;
                                y2=y2+1;
                                printf("2. x2= %d  y2= %d\n",x2,y2);
                                if(y2>=TAMANHO)
                                    cont4++;
                                if(cont4==0 && tabuleiro[x2][y2]==0){
                                    if(tabuleiro2[x2][y2]==cont30){
                                        vetor[x2][y2]=cont30;
                                        tabuleiro[x2][y2]=cont;
                                        cont++;
                                        num1=x2;
                                        num2=y2;
                                        x=i;
                                        y=j;
                                        cont6++;
                                        cont30=2;
                                        printf("\n\nAqui eu zero o  vetor nessa posição.\n");
                                        vetor[x2][y2]=0;
                                        printf("vetor = %d\n",vetor[x2][y2]);
                                        printf("Só que ao imprimir o vetor (abaixo) ele não aparece zerado\n");
                                        printf("Pelo menos no meu IDE ele não aparece zerado.\n\n");
                                        imprime(vetor);
                                        break;
                                    }
                                }
                                x2=x2-2;
                                y2=y2-1;
                                cont4=0;
                                movimento2++;
                                printf("2. x2= %d  y2= %d\n",x2,y2);
                                printf("cont30= %d\n",cont30);
                                printf("Dois dois\n\n\n");
                            }

                            if(movimento2==3){
                                x2=x2-1;
                                if(x2<0)
                                    cont4++;
                                y2=y2+2;
                                printf("3. x2= %d  y2= %d\n",x2,y2);
                                if(y2>=TAMANHO)
                                    cont4++;
                                if(cont4==0 && tabuleiro[x2][y2]==0){
                                    if(tabuleiro2[x2][y2]==cont20){
                                        tabuleiro[x2][y2]=cont;
                                        cont++;
                                        num1=x2;
                                        num2=y2;
                                        x=i;
                                        y=j;
                                        cont6++;
                                        cont30=2;
                                        printf("\n\nAqui eu zero o  vetor nessa posição.\n");
                                        vetor[x2][y2]=0;
                                        printf("vetor = %d\n",vetor[x2][y2]);
                                        printf("Só que ao imprimir o vetor (abaixo) ele não aparece zerado\n");
                                        printf("Pelo menos no meu IDE ele não aparece zerado.\n\n");
                                        imprime(vetor);
                                        break;
                                    }
                                }
                                x2=x2+1;
                                y2=y2-2;
                                cont4=0;
                                movimento2++;
                                printf("3. x2 %d  y2= %d\n",x2,y2);
                                printf("cont30= %d\n",cont30);
                                printf("Tres tres\n\n\n");
                            }

                            if(movimento2==4){
                                x2=x2-2;
                                if(x2<0)
                                    cont4++;
                                y2=y2+1;
                                printf("4. x2= %d  y2= %d\n",x2,y2);
                                if(y2>=TAMANHO)
                                    cont4++;
                                if(cont4==0 && tabuleiro[x2][y2]==0){
                                    if(tabuleiro2[x2][y2]==cont30){
                                        tabuleiro[x2][y2]=cont;
                                        cont++;
                                        num1=x2;
                                        num2=y2;
                                        x=i;
                                        y=j;
                                        cont6++;
                                        cont30=2;
                                        printf("\n\nAqui eu zero o  vetor nessa posição.\n");
                                        vetor[x2][y2]=0;
                                        printf("vetor = %d\n",vetor[x2][y2]);
                                        printf("Só que ao imprimir o vetor (abaixo) ele não aparece zerado\n");
                                        printf("Pelo menos no meu IDE ele não aparece zerado.\n\n");
                                        imprime(vetor);
                                        break;
                                    }
                                }
                                x2=x2+2;
                                y2=y2-1;
                                cont4=0;
                                movimento2++;
                                printf("4. x2= %d  y2= %d\n",x2,y2);
                                printf("cont30= %d\n",cont30);
                                printf("Quatro quatro\n\n\n");
                               }

                            if(movimento2==5){
                                x2=x2-1;
                                if(x2<0)
                                    cont4++;
                                y2=y2-2;
                                printf("5. x2= %d  y2= %d\n",x2,y2);
                                if(y2<0)
                                    cont4++;
                                if(cont4==0 && tabuleiro[x2][y2]==0){
                                    if(tabuleiro2[x2][y2]==cont30){
                                        tabuleiro[x2][y2]=cont;
                                        cont++;
                                        num1=x;
                                        num2=y;
                                        x=i;
                                        y=j;
                                        cont6++;
                                        cont30=2;
                                        printf("\n\nAqui eu zero o  vetor nessa posição.\n");
                                        vetor[x2][y2]=0;
                                        printf("vetor = %d\n",vetor[x2][y2]);
                                        printf("Só que ao imprimir o vetor (abaixo) ele não aparece zerado\n");
                                        printf("Pelo menos no meu IDE ele não aparece zerado.\n\n");
                                        imprime(vetor);
                                        break;
                                    }
                                }
                                x2=x2+1;
                                y2=y2+2;
                                cont4=0;
                                movimento2++;
                                printf("5. x2= %d  y2= %d\n",x2,y2);
                                printf("cont30= %d\n",cont30);
                                printf("Cinco cinco\n\n\n");
                            }

                            if(movimento2==6){
                                x2=x2+1;
                                if(x2>=TAMANHO)
                                    cont4++;
                                y2=y2-2;
                                printf("6. x2= %d  y2= %d\n",x2,y2);
                                if(y2<0)
                                    cont4++;
                                if(cont4==0 && tabuleiro[x2][y2]==0){
                                    if(tabuleiro2[x2][y2]==cont30){
                                        tabuleiro[x2][y2]=cont;
                                        cont++;
                                        num1=x;
                                        num2=y;
                                        x=i;
                                        y=j;
                                        cont6++;
                                        cont30=2;
                                        printf("\n\nAqui eu zero o  vetor nessa posição.\n");
                                        vetor[x2][y2]=0;
                                        printf("vetor = %d\n",vetor[x2][y2]);
                                        printf("Só que ao imprimir o vetor (abaixo) ele não aparece zerado\n");
                                        printf("Pelo menos no meu IDE ele não aparece zerado.\n\n");
                                        imprime(vetor);
                                        break;
                                    }
                                }
                                x2=x2-1;
                                y2=y2+2;
                                cont4=0;
                                movimento2++;
                                printf("6. x2= %d  y2= %d\n",x2,y2);
                                printf("cont30= %d\n",cont30);
                                printf("Seis seis\n\n\n");
                            }

                            if(movimento2==7){
                                x2=x2-2;
                                if(x2<0)
                                    cont4++;
                                y2=y2-1;
                                printf("7. x2= %d  y2= %d\n",x2,y2);
                                if(y2<0)
                                    cont4++;
                                if(cont4==0 && tabuleiro[x2][y2]==0){
                                    if(tabuleiro2[x2][y2]==cont30){
                                        tabuleiro[x2][y2]=cont;
                                        cont++;
                                        num1=x;
                                        num2=y;
                                        x=i;
                                        y=j;
                                        cont6++;
                                        cont30=2;
                                        printf("\n\nAqui eu zero o  vetor nessa posição.\n");
                                        vetor[x2][y2]=0;
                                        printf("vetor = %d\n",vetor[x2][y2]);
                                        printf("Só que ao imprimir o vetor (abaixo) ele não aparece zerado\n");
                                        printf("Pelo menos no meu IDE ele não aparece zerado.\n\n");
                                        imprime(vetor);
                                        break;
                                    }
                                }
                                x2=x2+2;
                                y2=y2+1;
                                cont4=0;
                                movimento2++;
                                printf("7. x2= %d  y2= %d\n",x2,y2);
                                printf("cont30= %d\n",cont30);
                                printf("Sete sete\n\n\n");
                            }

                            if(movimento2==8){
                                x2=x2+2;
                                if(x2>=TAMANHO)
                                    cont4++;
                                y2=y2-1;
                                printf("8. x2= %d  y2= %d\n",x2,y2);
                                if(y2<0)
                                    cont4++;
                                if(cont4==0 && tabuleiro[x2][y2]==0){
                                    if(tabuleiro2[x2][y2]==cont30){
                                        tabuleiro[x2][y2]=cont;
                                        cont++;
                                        num1=x;
                                        num2=y;
                                        x=i;
                                        y=j;
                                        cont6++;
                                        cont30=2;
                                       printf("\n\nAqui eu zero o  vetor nessa posição.\n");
                                        vetor[x2][y2]=0;
                                        printf("vetor = %d\n",vetor[x2][y2]);
                                        printf("Só que ao imprimir o vetor (abaixo) ele não aparece zerado\n");
                                        printf("Pelo menos no meu IDE ele não aparece zerado.\n\n");
                                        imprime(vetor);
                                        break;
                                    }
                                }
                                x2=x2-2;
                                y2=y2+1;
                                cont4=0;
                                movimento2++;
                                printf("8. x2= %d  y2= %d\n",x2,y2);
                                printf("cont30= %d\n",cont30);
                                printf("Oito oito\n\n\n");
                            }
                        }
                    }
                     if(cont6==1){      //cont6==1 significa que o
                for(i=0;i<TAMANHO;i++){ //programa já encontrou um valor
                    for(j=0;j<TAMANHO;j++){  //Estou zerando o vetor novamente
                        vetor[x][y]=0;      //para armazenar novos valores
                                            //Só que não zera
                                            //Não entendo o porquê
                    }
                }
                break;      //Saindo do for
                }
                }
              if(cont6==1){
                for(i=0;i<TAMANHO;i++){     //zerando o vetor novamente
                    for(j=0;j<TAMANHO;j++){ // Novamente Não zera
                        vetor[x][y]=0;
                    }
                }
                break;      //Saindo do while
                }
                cont30++;  //mesma função do cont20
            }               //na primeira parte do programa
                        }
                        cont3=0;
                        movimento=1;
                        imprime(tabuleiro);
                    }
}

void imprime(int a[TAMANHO][TAMANHO]){
    int i,j;

    printf("\n\n\n");
    for(i=0;i<TAMANHO;i++){
        for(j=0;j<TAMANHO;j++){
            printf("%3d",a[i][j]);
            Sleep(100);
        }
        printf("\n\n");
    }
    printf("\n\n\n");
}

 

[arfneto]

Antes de tudo: veja a esquerda a posição da barra de scroll... Isso é para conseguir ler a terceira linha do seu texto. Não poste assim com linhas enormes sem quebra: para poder ler tem que ir pro final do texto, que é enorme. usar a barra de scroll e voltar pra cima. Impossivel quase. E certamente muito chato.

 

Por favor não poste textos assim. Mesmo em programas evite passar de umas 60 colunas ou o texto quebra e fica difícil de ler, outro lado do mesmo problema.

 

O software do forum poderia ser melhor, mas não é. Não ajuda em nada. Ou eu não sei usar, claro.

 

Note que essa linha 3 tem nada menos de 596 colunas :)

 

E não é a única assim... :(

 

 

 

Compare com o  (mesmo) texto abaixo:

 

Spoiler

Exercício 6.24 Como programar em C – H.M.Deitel  e P.J.Deitel
Eu estou com problemas em resolver o exercício abaixo.
Ele já está quase funcionando, mas  tem algo que não está funcionando
direito com relação à um vetor.
Eu acumulo algumas posições para comparar qual a mais adequada 
para o próximo passo a ser dado.
O programa seleciona estes movimentos os utiliza.
E então eu tenho que zerar o vetor.
Já fiz  isso em três lugares diferentes e o vetor não
“zera” de modo nenhum.
Como eu tenho problemas de um cara que
invade o meu computador e altera o meu IDE.
Eu não sei  se é algo que eu estou fazendo errado, ou se é “zoeira”
desse cara que me persegue.
Se alguém puder tentar me ajudar, eu agradeço.
O programa está todo comentado e também está com vários  “marcadores” 
que eu fiz procurando  erros.

Outra coisa.

O programa é para ser feito utilizando somente vetores.
Nesta parte do livro ainda não se chegou  em  struct, filas ou ponteiros.
Eu fiz um programa em um bloco único.Assim que ele estiver rodando eu o divido em funções.

Desde já os meus agradecimentos.

Enunciado :

    Um dos problemas mais interessantes para os  fãs do jogo de xadrez
    é o problema do Passeio do Cavalo proposto originalmente pelo matemático Euler.

    A questão é esta : a peça do jogo de xadrez  chamada cavalo pode mover
    ao longo de um tabuleiro vazio e passar uma única vez em cada uma das 64 casas.
    
    O cavalo faz movimentos em formato de  ”L”(percorre duas casas em  uma
    direção  e uma no sentido perpendicular às duas primeiras.
    Dessa forma de uma casa no meio do tabuleiro, o cavalo pode fazer
    8 movimentos diferentes, ou seja, ele pode se movimentar :

Movimento 1. Mover 2 posições à direita e 1 para baixo;
Movimento 2.  Mover 1 posição à direita e 2 para baixo;
Movimento 3. Mover 2 posições à direita e 1 para cima;
Movimento 4. Mover 1 posição à direita e 2 para cima;

Desenvolva um programa que moverá o cavalo pelo tabuleiro de xadrez.
O tabuleiro em si é representado  pelo array bidimensional  8 - por - 8 tabuleiro.
Cada um dos quadrados(casas) é inicializado com o valor zero.

Utilize um contador que varie de 1 à 64.

Lembre-se de testar cada movimento potencial para se certificar
de que o cavalo não está saindo do tabuleiro.
Os quadrados estão classificados de acordo com a sua acessibilidade
pelo vetor tabuleiro2  onde deve - se mover o cavalo(dentro dos movimentos
em forma de “L”) para o quadrado que seja mais inacessível.

Os números  do vetor tabuleiro2 indicam a partir de quantos quadrados um determinado
quadrado pode ser acessado.
O cavalo deve se mover para o quadrado com menor número de acessibilidade.
Em caso de empate o   cavalo pode se mover para qualquer um dos quadrados que empataram.

Até aqui eu fiz.

Só que a continuação do exercício pede que agora o exercício seja
modificado de modo a que  quando houver um empate entre  dois ou mais
quadrados a escolha seja feita verificando os quadrados que podem ser
alcançados a partir dos quadrados empatados.

O programa deve fazer o movimento do cavalo para o quadrado para o qual
o próximo movimento levar ao quadrado com menor número de acessibilidade.

Por exemplo :

Eu preenchi um quadrado e no próximo movimento existem duas posições que
eu posso acessar de onde estou.O programa deve verificar qual das duas
posições possui um número menor  no vetor tabuleiro2.

 

 

E o (mesmo) programa :
 

Spoiler

#include <stdio.h>
#include <stdlib.h>
#include <locale.h>
#include <windows.h>
#define TAMANHO 8
void imprime(int a[TAMANHO][TAMANHO]);

int main()
{
    int i, j, tabuleiro[TAMANHO][TAMANHO] = { 0 };
    static int x2, y2, num1 = 0, num2 = 0, movimento2 = 1, cont30 = 2, cont4 = 0, cont6 = 0;
    static int x = 0, y = 0, cont = 0, cont2 = 0, cont3 = 0, cont20 = 2, movimento = 1, vetor[TAMANHO][TAMANHO] = { 0 };
    static int tabuleiro2[TAMANHO][TAMANHO] = { {2,3,4,4,4,4,3,2},
                                              {3,4,6,6,6,6,4,3},
                                              {4,6,8,8,8,8,6,4},
                                              {4,6,8,8,8,8,6,4},
                                              {4,6,8,8,8,8,6,4},
                                              {4,6,8,8,8,8,6,4},
                                              {3,4,6,6,6,6,4,3},
                                              {2,3,4,4,4,4,3,2} };
    setlocale(LC_ALL, "");
    while (cont < 64) {
        printf(" 1. Mover 2 posições à direita e 1 para baixo\n");
        printf(" 2. Mover 1 posição à direita e 2 para baixo\n");
        printf(" 3. Mover 2 posições à direita e 1 para cima\n");
        printf(" 4. Mover 1 posição à direita e 2 para cima\n");
        printf(" 5. Mover 2 posições à esquerda e 1 para cima\n");
        printf(" 6. Mover 2 posições à esquerda e 1 para baixo\n");
        printf(" 7. Mover 1 posição à esquerda e 2 para cima\n");
        printf(" 8. Mover 1 posição à esquerda e 2 para baixo\n");

        if (movimento == 1) {
            x = x + 1;                  //Testa  o movimento 1
            if (x >= TAMANHO)          //Verifica se a linha
                cont2++;            //pertence ao tabuleiro
            y = y + 2;
            printf("1. x= %d  y= %d\n", x, y);
            if (y >= TAMANHO)       //Verifica se a coluna
                cont2++;        //pertence ao tabuleiro
            if (cont2 == 0 && tabuleiro[x][y] == 0) {//Verifica se a posição está vazia
                if (tabuleiro2[x][y] == cont20) { //verifica se nessa posição está
                    vetor[x][y] = cont20;       //o menor valor do vetor
                    tabuleiro[x][y] = cont;   //Adiciona este movimento ao vetor
                    cont++;
                    num1 = x;            //cont20 ´começa do menos valor
                    num2 = y;            //que é 2 e vai até 8
                    cont3++;           // que são as posições do tabuleiro2
                }                      //cont3 conta quantas posições ue servem
            }                           //foram encontradas
            x = x - 1;          //x w y retornam ao valor anterior
            y = y - 2;          //para continuar a busca
            cont2 = 0;
            movimento++;
            printf("1. x= %d  y= %d\n", x, y);
            printf("cont20= %d\n", cont20);
            printf("cont3= %d\n\n", cont3);
        }

        if (movimento == 2) {
            x = x + 2;
            if (x >= TAMANHO)
                cont2++;
            y = y + 1;
            printf("2. x= %d  y= %d\n", x, y);
            if (y >= TAMANHO)
                cont2++;
            if (cont2 == 0 && tabuleiro[x][y] == 0) {
                if (tabuleiro2[x][y] == cont20) {
                    vetor[x][y] = cont20;
                    tabuleiro[x][y] = cont;
                    cont++;
                    num1 = x;
                    num2 = y;
                    cont3++;
                }
            }
            x = x - 2;
            y = y - 1;
            cont2 = 0;
            movimento++;
            printf("2. x= %d  y= %d\n", x, y);
            printf("cont20= %d\n", cont20);
            printf("cont3= %d\n\n", cont3);
        }

        if (movimento == 3) {
            x = x - 1;
            if (x < 0)
                cont2++;
            y = y + 2;
            printf("3. x= %d  y= %d\n", x, y);
            if (y >= TAMANHO)
                cont2++;
            if (cont2 == 0 && tabuleiro[x][y] == 0) {
                if (tabuleiro2[x][y] == cont20) {
                    vetor[x][y] = cont20;
                    tabuleiro[x][y] = cont;
                    cont++;
                    num1 = x;
                    num2 = y;
                    cont3++;
                }
            }
            x = x + 1;
            y = y - 2;
            cont2 = 0;
            movimento++;
            printf("3. x= %d  y= %d\n", x, y);
            printf("cont20= %d\n", cont20);
            printf("cont3= %d\n\n", cont3);
        }

        if (movimento == 4) {
            x = x - 2;
            if (x < 0)
                cont2++;
            y = y + 1;
            printf("4. x= %d  y= %d\n", x, y);
            if (y >= TAMANHO)
                cont2++;
            if (cont2 == 0 && tabuleiro[x][y] == 0) {
                if (tabuleiro2[x][y] == cont20) {
                    vetor[x][y] = cont20;
                    tabuleiro[x][y] = cont;
                    cont++;
                    num1 = x;
                    num2 = y;
                    cont3++;
                }
            }
            x = x + 2;
            y = y - 1;
            cont2 = 0;
            movimento++;
            printf("4. x= %d  y= %d\n", x, y);
            printf("cont20= %d\n", cont20);
            printf("cont3= %d\n\n", cont3);
        }

        if (movimento == 5) {
            x = x - 1;
            if (x < 0)
                cont2++;
            y = y - 2;
            printf("5. x= %d  y= %d\n", x, y);
            if (y < 0)
                cont2++;
            if (cont2 == 0 && tabuleiro[x][y] == 0) {
                if (tabuleiro2[x][y] == cont20) {
                    vetor[x][y] = cont20;
                    tabuleiro[x][y] = cont;
                    cont++;
                    num1 = x;
                    num2 = y;
                    cont3++;
                }
            }
            x = x + 1;
            y = y + 2;
            cont2 = 0;
            movimento++;
            printf("5. x= %d  y= %d\n", x, y);
            printf("cont20= %d\n", cont20);
            printf("cont3= %d\n\n", cont3);
        }

        if (movimento == 6) {
            x = x + 1;
            if (x >= TAMANHO)
                cont2++;
            y = y - 2;
            printf("6. x= %d  y= %d\n", x, y);
            if (y < 0)
                cont2++;
            if (cont2 == 0 && tabuleiro[x][y] == 0) {
                if (tabuleiro2[x][y] == cont20) {
                    vetor[x][y] = cont20;
                    tabuleiro[x][y] = cont;
                    cont++;
                    num1 = x;
                    num2 = y;
                    cont3++;
                }
            }
            x = x - 1;
            y = y + 2;
            cont2 = 0;
            movimento++;
            printf("6. x= %d  y= %d\n", x, y);
            printf("cont20= %d\n", cont20);
            printf("cont3= %d\n\n", cont3);
        }

        if (movimento == 7) {
            x = x - 2;
            if (x < 0)
                cont2++;
            y = y - 1;
            printf("7. x= %d  y= %d\n", x, y);
            if (y < 0)
                cont2++;
            if (cont2 == 0 && tabuleiro[x][y] == 0) {
                if (tabuleiro2[x][y] == cont20) {
                    vetor[x][y] = cont20;
                    tabuleiro[x][y] = cont;
                    cont++;
                    num1 = x;
                    num2 = y;
                    cont3++;
                }
            }
            x = x + 2;
            y = y + 1;
            cont2 = 0;
            movimento++;
            printf("7. x= %d  y= %d\n", x, y);
            printf("cont20= %d\n", cont20);
            printf("cont3= %d\n\n", cont3);
        }

        if (movimento == 8) {
            x = x + 2;
            if (x >= TAMANHO)
                cont2++;
            y = y - 1;
            printf("8. x= %d  y= %d\n", x, y);
            if (y < 0)
                cont2++;
            if (cont2 == 0 && tabuleiro[x][y] == 0) {
                if (tabuleiro2[x][y] == cont20) {
                    vetor[x][y] = cont20;
                    tabuleiro[x][y] = cont;
                    cont++;
                    num1 = x;
                    num2 = y;
                    cont3++;
                }
            }
            x = x - 2;
            y = y + 1;
            cont2 = 0;
            movimento++;
            printf("8. x= %d  y= %d\n", x, y);
            printf("cont20= %d\n", cont20);
            printf("cont3= %d\n\n", cont3);
        }


        if (cont3 == 0) {
            if (cont20 == 8)       //Se cont3==0 significa que
                cont20 = 2;       //nenhuma posição é igual a
            else                //cont20.
                cont20++;
        }
        if (cont3 == 1) {
            x = num1;
            y = num2;
            for (i = 0; i < TAMANHO; i++) {
                for (j = 0; j < TAMANHO; j++) {
                    vetor[x][y] = 0;
                }
            }
            cont20 = 2;
            cont3 = 0;
        }
        if (cont3 > 1) {
            //cont=cont-cont3+1;
            printf("Maior que 1\n");
            movimento2 = 1;
            while (cont30 < 8) {
                for (i = 0; i < TAMANHO; i++) {
                    Sleep(100);
                    for (j = 0; j < TAMANHO; j++) {
                        cont6 = 0;
                        Sleep(100);
                        //*********
                        printf("\n\n*UM\n\n\n");
                        //*******
                        Sleep(100);
                        if (vetor[i][j] != 0) {
                            movimento2 = 1;

                            printf("\n\nDOIS\n\n\n");
                            Sleep(100);

                            printf("vetor[%d][%d]= %d\n", i, j, vetor[i][j]);
                            printf("movimento2= %d\n", movimento2);
                            x2 = i;
                            y2 = j;
                            if (movimento2 == 1) {
                                x2 = x2 + 1;
                                if (x2 >= TAMANHO)
                                    cont4++;
                                y2 = y2 + 2;
                                printf("1. x2= %d  y2= %d\n", x2, y2);
                                if (y2 >= TAMANHO)
                                    cont4++;
                                if (cont4 == 0 && tabuleiro[x2][y2] == 0) {
                                    if (tabuleiro2[x2][y2] == cont30) {
                                        tabuleiro[x2][y2] = cont;
                                        cont++;
                                        num1 = x2;
                                        num2 = y2;
                                        x = i;
                                        y = j;
                                        cont6++;
                                        cont30 = 2;
                                        printf("\n\nAqui eu zero o  vetor nessa posição.\n");
                                        vetor[x2][y2] = 0;
                                        printf("vetor = %d\n", vetor[x2][y2]);
                                        printf("Só que ao imprimir o vetor (abaixo) ele não aparece zerado\n");
                                        printf("Pelo menos no meu IDE ele não aparece zerado.\n\n");
                                        imprime(vetor);
                                        break;
                                    }
                                }
                                x2 = x2 - 1;
                                y2 = y2 - 2;
                                cont4 = 0;
                                movimento2++;
                                printf("1. x2= %d  y2= %d\n", x2, y2);
                                printf("cont30= %d\n", cont30);
                                printf("\n\nUm um\n\n\n");
                            }

                            if (movimento2 == 2) {
                                x2 = x2 + 2;
                                if (x2 >= TAMANHO)
                                    cont4++;
                                y2 = y2 + 1;
                                printf("2. x2= %d  y2= %d\n", x2, y2);
                                if (y2 >= TAMANHO)
                                    cont4++;
                                if (cont4 == 0 && tabuleiro[x2][y2] == 0) {
                                    if (tabuleiro2[x2][y2] == cont30) {
                                        vetor[x2][y2] = cont30;
                                        tabuleiro[x2][y2] = cont;
                                        cont++;
                                        num1 = x2;
                                        num2 = y2;
                                        x = i;
                                        y = j;
                                        cont6++;
                                        cont30 = 2;
                                        printf("\n\nAqui eu zero o  vetor nessa posição.\n");
                                        vetor[x2][y2] = 0;
                                        printf("vetor = %d\n", vetor[x2][y2]);
                                        printf("Só que ao imprimir o vetor (abaixo) ele não aparece zerado\n");
                                        printf("Pelo menos no meu IDE ele não aparece zerado.\n\n");
                                        imprime(vetor);
                                        break;
                                    }
                                }
                                x2 = x2 - 2;
                                y2 = y2 - 1;
                                cont4 = 0;
                                movimento2++;
                                printf("2. x2= %d  y2= %d\n", x2, y2);
                                printf("cont30= %d\n", cont30);
                                printf("Dois dois\n\n\n");
                            }

                            if (movimento2 == 3) {
                                x2 = x2 - 1;
                                if (x2 < 0)
                                    cont4++;
                                y2 = y2 + 2;
                                printf("3. x2= %d  y2= %d\n", x2, y2);
                                if (y2 >= TAMANHO)
                                    cont4++;
                                if (cont4 == 0 && tabuleiro[x2][y2] == 0) {
                                    if (tabuleiro2[x2][y2] == cont20) {
                                        tabuleiro[x2][y2] = cont;
                                        cont++;
                                        num1 = x2;
                                        num2 = y2;
                                        x = i;
                                        y = j;
                                        cont6++;
                                        cont30 = 2;
                                        printf("\n\nAqui eu zero o  vetor nessa posição.\n");
                                        vetor[x2][y2] = 0;
                                        printf("vetor = %d\n", vetor[x2][y2]);
                                        printf("Só que ao imprimir o vetor (abaixo) ele não aparece zerado\n");
                                        printf("Pelo menos no meu IDE ele não aparece zerado.\n\n");
                                        imprime(vetor);
                                        break;
                                    }
                                }
                                x2 = x2 + 1;
                                y2 = y2 - 2;
                                cont4 = 0;
                                movimento2++;
                                printf("3. x2 %d  y2= %d\n", x2, y2);
                                printf("cont30= %d\n", cont30);
                                printf("Tres tres\n\n\n");
                            }

                            if (movimento2 == 4) {
                                x2 = x2 - 2;
                                if (x2 < 0)
                                    cont4++;
                                y2 = y2 + 1;
                                printf("4. x2= %d  y2= %d\n", x2, y2);
                                if (y2 >= TAMANHO)
                                    cont4++;
                                if (cont4 == 0 && tabuleiro[x2][y2] == 0) {
                                    if (tabuleiro2[x2][y2] == cont30) {
                                        tabuleiro[x2][y2] = cont;
                                        cont++;
                                        num1 = x2;
                                        num2 = y2;
                                        x = i;
                                        y = j;
                                        cont6++;
                                        cont30 = 2;
                                        printf("\n\nAqui eu zero o  vetor nessa posição.\n");
                                        vetor[x2][y2] = 0;
                                        printf("vetor = %d\n", vetor[x2][y2]);
                                        printf("Só que ao imprimir o vetor (abaixo) ele não aparece zerado\n");
                                        printf("Pelo menos no meu IDE ele não aparece zerado.\n\n");
                                        imprime(vetor);
                                        break;
                                    }
                                }
                                x2 = x2 + 2;
                                y2 = y2 - 1;
                                cont4 = 0;
                                movimento2++;
                                printf("4. x2= %d  y2= %d\n", x2, y2);
                                printf("cont30= %d\n", cont30);
                                printf("Quatro quatro\n\n\n");
                            }

                            if (movimento2 == 5) {
                                x2 = x2 - 1;
                                if (x2 < 0)
                                    cont4++;
                                y2 = y2 - 2;
                                printf("5. x2= %d  y2= %d\n", x2, y2);
                                if (y2 < 0)
                                    cont4++;
                                if (cont4 == 0 && tabuleiro[x2][y2] == 0) {
                                    if (tabuleiro2[x2][y2] == cont30) {
                                        tabuleiro[x2][y2] = cont;
                                        cont++;
                                        num1 = x;
                                        num2 = y;
                                        x = i;
                                        y = j;
                                        cont6++;
                                        cont30 = 2;
                                        printf("\n\nAqui eu zero o  vetor nessa posição.\n");
                                        vetor[x2][y2] = 0;
                                        printf("vetor = %d\n", vetor[x2][y2]);
                                        printf("Só que ao imprimir o vetor (abaixo) ele não aparece zerado\n");
                                        printf("Pelo menos no meu IDE ele não aparece zerado.\n\n");
                                        imprime(vetor);
                                        break;
                                    }
                                }
                                x2 = x2 + 1;
                                y2 = y2 + 2;
                                cont4 = 0;
                                movimento2++;
                                printf("5. x2= %d  y2= %d\n", x2, y2);
                                printf("cont30= %d\n", cont30);
                                printf("Cinco cinco\n\n\n");
                            }

                            if (movimento2 == 6) {
                                x2 = x2 + 1;
                                if (x2 >= TAMANHO)
                                    cont4++;
                                y2 = y2 - 2;
                                printf("6. x2= %d  y2= %d\n", x2, y2);
                                if (y2 < 0)
                                    cont4++;
                                if (cont4 == 0 && tabuleiro[x2][y2] == 0) {
                                    if (tabuleiro2[x2][y2] == cont30) {
                                        tabuleiro[x2][y2] = cont;
                                        cont++;
                                        num1 = x;
                                        num2 = y;
                                        x = i;
                                        y = j;
                                        cont6++;
                                        cont30 = 2;
                                        printf("\n\nAqui eu zero o  vetor nessa posição.\n");
                                        vetor[x2][y2] = 0;
                                        printf("vetor = %d\n", vetor[x2][y2]);
                                        printf("Só que ao imprimir o vetor (abaixo) ele não aparece zerado\n");
                                        printf("Pelo menos no meu IDE ele não aparece zerado.\n\n");
                                        imprime(vetor);
                                        break;
                                    }
                                }
                                x2 = x2 - 1;
                                y2 = y2 + 2;
                                cont4 = 0;
                                movimento2++;
                                printf("6. x2= %d  y2= %d\n", x2, y2);
                                printf("cont30= %d\n", cont30);
                                printf("Seis seis\n\n\n");
                            }

                            if (movimento2 == 7) {
                                x2 = x2 - 2;
                                if (x2 < 0)
                                    cont4++;
                                y2 = y2 - 1;
                                printf("7. x2= %d  y2= %d\n", x2, y2);
                                if (y2 < 0)
                                    cont4++;
                                if (cont4 == 0 && tabuleiro[x2][y2] == 0) {
                                    if (tabuleiro2[x2][y2] == cont30) {
                                        tabuleiro[x2][y2] = cont;
                                        cont++;
                                        num1 = x;
                                        num2 = y;
                                        x = i;
                                        y = j;
                                        cont6++;
                                        cont30 = 2;
                                        printf("\n\nAqui eu zero o  vetor nessa posição.\n");
                                        vetor[x2][y2] = 0;
                                        printf("vetor = %d\n", vetor[x2][y2]);
                                        printf("Só que ao imprimir o vetor (abaixo) ele não aparece zerado\n");
                                        printf("Pelo menos no meu IDE ele não aparece zerado.\n\n");
                                        imprime(vetor);
                                        break;
                                    }
                                }
                                x2 = x2 + 2;
                                y2 = y2 + 1;
                                cont4 = 0;
                                movimento2++;
                                printf("7. x2= %d  y2= %d\n", x2, y2);
                                printf("cont30= %d\n", cont30);
                                printf("Sete sete\n\n\n");
                            }

                            if (movimento2 == 8) {
                                x2 = x2 + 2;
                                if (x2 >= TAMANHO)
                                    cont4++;
                                y2 = y2 - 1;
                                printf("8. x2= %d  y2= %d\n", x2, y2);
                                if (y2 < 0)
                                    cont4++;
                                if (cont4 == 0 && tabuleiro[x2][y2] == 0) {
                                    if (tabuleiro2[x2][y2] == cont30) {
                                        tabuleiro[x2][y2] = cont;
                                        cont++;
                                        num1 = x;
                                        num2 = y;
                                        x = i;
                                        y = j;
                                        cont6++;
                                        cont30 = 2;
                                        printf("\n\nAqui eu zero o  vetor nessa posição.\n");
                                        vetor[x2][y2] = 0;
                                        printf("vetor = %d\n", vetor[x2][y2]);
                                        printf("Só que ao imprimir o vetor (abaixo) ele não aparece zerado\n");
                                        printf("Pelo menos no meu IDE ele não aparece zerado.\n\n");
                                        imprime(vetor);
                                        break;
                                    }
                                }
                                x2 = x2 - 2;
                                y2 = y2 + 1;
                                cont4 = 0;
                                movimento2++;
                                printf("8. x2= %d  y2= %d\n", x2, y2);
                                printf("cont30= %d\n", cont30);
                                printf("Oito oito\n\n\n");
                            }
                        }
                    }
                    if (cont6 == 1) {      //cont6==1 significa que o
                        for (i = 0; i < TAMANHO; i++) { //programa já encontrou um valor
                            for (j = 0; j < TAMANHO; j++) {  //Estou zerando o vetor novamente
                                vetor[x][y] = 0;      //para armazenar novos valores
                                                    //Só que não zera
                                                    //Não entendo o porquê
                            }
                        }
                        break;      //Saindo do for
                    }
                }
                if (cont6 == 1) {
                    for (i = 0; i < TAMANHO; i++) {     //zerando o vetor novamente
                        for (j = 0; j < TAMANHO; j++) { // Novamente Não zera
                            vetor[x][y] = 0;
                        }
                    }
                    break;      //Saindo do while
                }
                cont30++;  //mesma função do cont20
            }               //na primeira parte do programa
        }
        cont3 = 0;
        movimento = 1;
        imprime(tabuleiro);
    }
}

void imprime(int a[TAMANHO][TAMANHO]) {
    int i, j;

    printf("\n\n\n");
    for (i = 0; i < TAMANHO; i++) {
        for (j = 0; j < TAMANHO; j++) {
            printf("%3d", a[i][j]);
            Sleep(100);
        }
        printf("\n\n");
    }
    printf("\n\n\n");
}

 

 

De volta ao programa

 

Seu programa parece desnecessariamente complicado

 

Não conheço o livro, mas já ouvi falar doproblema do cavalo :( E ao menos jogo xadrez. Ou jogava.

 

Não está claro o que o enunciado pede pra fazer.  Vai escolher uma posição inicial e tentar resolver o problema para uma dada posição? Ou apenas ficar movendo o cavalo até acabarem os movimentos para uma dada posição inicial? Não que isso mude muito as coisas. Não sei se isso tem de fato solução para algum ou todos pontos de partida, e o número de possibilidades é, digamos, imenso...

 

Talvez possa computar o melhor resultado para um certo tempo, tipo 1 minuto ou uma hora, não sei. De todo modo isso não interfere muito na mecânica do "jogo" em si.

 

A sua lista de 8 movimentos diferentes mas com 4 movimentos apenas foi divertida de ler :)

 

Citação

Desenvolva um programa que moverá o cavalo pelo tabuleiro de xadrez.
O tabuleiro em si é representado  pelo array bidimensional  8 - por - 8 tabuleiro.

 

Então se é só para mover pode ser bem mais simples, mas não vai resolver nada. Só mover a "peça". Não vai acompanhar quantas das 64 casas andou? De onde iniciou? Vai salvar o caminho?

 

Citação

Cada um dos quadrados(casas) é inicializado com o valor zero.

Utilize um contador que varie de 1 à 64.

 

Não entendo a razão do autor se preocupar em como vai implementar o tabuleiro. Irrelevante.

 

Citação

Os quadrados estão classificados de acordo com a sua acessibilidade
pelo vetor tabuleiro2  onde deve - se mover o cavalo(dentro dos movimentos
em forma de “L”) para o quadrado que seja mais inacessível.

Os números  do vetor tabuleiro2 indicam a partir de quantos quadrados um determinado
quadrado pode ser acessado.

 

Mais inacessível? Seria o que? O de menor valor em tabuleiro2?

 

Citação

Só que a continuação do exercício pede que agora o exercício seja
modificado de modo a que  quando houver um empate entre  dois ou mais
quadrados a escolha seja feita verificando os quadrados que podem ser
alcançados a partir dos quadrados empatados.

 

Mas no movimento seguinte essa aparente vantagem pode desaparecer. É um caso de "visão curta": pode ser que ao tentar num primeiro momento um lugar menos acessível leve a um percurso melhor nos próximos movimentos. Seria melhor uma amostragem para um certo número de lances adiante. Confesso que estou escrevendo sem pensar muito...

 

Citação

Como eu tenho problemas de um cara que
invade o meu computador e altera o meu IDE.

 

Fala sério? Que IDE é esse? e porque não compila simplesmente, já que é um programa pequeno de um arquivo só? E como um "cara" invade seguidamente seu computador?

 

Mais do programa
 

Citação

O programa é para ser feito utilizando somente vetores.
Nesta parte do livro ainda não se chegou  em  struct, filas ou ponteiros.
Eu fiz um programa em um bloco único.Assim que ele estiver rodando eu o divido em funções.

 

Está jogando contra seu próprio objetivo. Em problemas reais, ou menos reais até, a primeira coisa que se faz é buscar um modelo, um algoritmo, conhecimentos que ajudem a implementar a solução. Não se aprende muito ao se limitar até a página do livro que está lendo ou ao que viu até a última aula. A gente em geral aprende para resolver o problema e não o contrário: resolve o problema para aprender. Esses exercícios são uma técnica de fixação apenas.

 

"Assim que estiver rodando eu divido em funções" é a pior ideia: uma vez que saiba que pode escrever uma função deve aprender e usar. E muito. E se não sabe deve rapidamente concluir que deve existir algo assim, um bloco de código que você possa chamar de algum modo. Nada vai aprender por ter escrito um programa de 2000 linhas copiando o que seria uma função 20 vezes, por exemplo. E você usou uma função...

 

Algoritmos

 

Para seu problema há dois mapas: o de origem e o de destino.

• O mapa de destino
  • cada ponto --- "casa" --- tem um correspondente conjunto de até 8 destinos,
    os movimentos válidos do cavalo a partir dele.
• O mapa de origem
  • cada ponto tem um similar conjunto de pontos a partir dos quais ele pode ser atingido

Esses dois mapas são a mesma coisa porque o movimento é simétrico.

 

Use nomes mais significativos... Veja abaixo suas declarações:
 

    static int x2, y2, num1 = 0, num2 = 0, movimento2 = 1,
      cont30 = 2, cont4 = 0, cont6 = 0;
    static int x = 0, y = 0, cont = 0, cont2 = 0, cont3 = 0,
      cont20 = 2, movimento = 1, vetor[TAMANHO][TAMANHO] = { 0 };
    int i, j, tabuleiro[TAMANHO][TAMANHO] = { 0 };
    static int x2, y2, num1 = 0, num2 = 0, movimento2 = 1, cont30 = 2,
		cont4 = 0, cont6 = 0;
    static int x = 0, y = 0, cont = 0, cont2 = 0, cont3 = 0, cont20 = 2,
		movimento = 1, vetor[TAMANHO][TAMANHO] = { 0 };
    static int tabuleiro2[TAMANHO][TAMANHO] = { 
        {2,3,4,4,4,4,3,2},
        {3,4,6,6,6,6,4,3},
        {4,6,8,8,8,8,6,4},
        {4,6,8,8,8,8,6,4},
        {4,6,8,8,8,8,6,4},
        {4,6,8,8,8,8,6,4},
        {3,4,6,6,6,6,4,3},
        {2,3,4,4,4,4,3,2}
    };

 

Use nomes mais expressivos.

 

Que pretende ao declarar variáveis static em main()? Quando sair de main() o programa acabou... Quando entra em main() o programa começou. main() não é reentrante.

 

Não declare mais de uma variável por linha.

 

A única função de seu programa é imprime()? Só está dificultando as coisas. E para que uma pausa na impressão? Sleep(100)?
 

        printf(" 1. Mover 2 posições à direita e 1 para baixo\n");
        printf(" 2. Mover 1 posição à direita e 2 para baixo\n");
        printf(" 3. Mover 2 posições à direita e 1 para cima\n");
        printf(" 4. Mover 1 posição à direita e 2 para cima\n");
        printf(" 5. Mover 2 posições à esquerda e 1 para cima\n");
        printf(" 6. Mover 2 posições à esquerda e 1 para baixo\n");
        printf(" 7. Mover 1 posição à esquerda e 2 para cima\n");
        printf(" 8. Mover 1 posição à esquerda e 2 para baixo\n");

 

Para que servem esses printf() ?

 

Acho que não entendi :) mas quero ajudar...

 

Recomendo mudar essas coisas de que falei e escrever uma função que devolve o score() de um possível destino, para acelerar as contas. E uma outra que devolve o melhor score para uma posição, onde vai entrar esse refinamento introduzido depois no enunciado.

 

Talvez deva salvar o percurso todo e comprimento atual dele, e assim ao eventualmente não ter mais posições para ir possa listar o percurso.

 

E receber como parâmetro a posição inicial do cavalo pode ser interessante. Talvez usar a notação clássica de xadrez também, de a1 a h8, porque é o caminho simples de alguém entender uma listagem de movimentos do cavalo....

 

 

 

 

 

 

 

 

 

[arfneto]

Não respondeu nada do que perguntou. Espero que tenha conseguido implementar uma solução.

 

Estive pensando e experimentando um pouco com seu problema. Mais uns palpites:

• está repetindo no programa sempre os movimentos e testando coisas que são constantes para sempre. Os movimentos estão todos definidos. Pode ter uma simples matriz com os poss;iveis movimentos e acessar direto, sem testar nada mais.
• pode ter um terceiro tabuleiro com o alcance do destino 

[Cristina2000]

Em 26/01/2021 às 21:09, Cristina2000 disse:

Exercício 6.24 Como programar em C – H.M. Deitel  e P.J.Deitel
.
Eu estou com problemas em resolver o exercício abaixo. Ele já está quase funcionando, mas  tem algo que não está funcionando direito com relação à um vetor. Eu acumulo algumas posições para comparar qual a mais adequada para o próximo passo a ser dado. O programa seleciona estes movimentos os utiliza. E então eu tenho que zerar o vetor. Já fiz  isso em três lugares diferentes e o vetor não “zera” de modo nenhum. Como eu tenho problemas de um cara que invade o meu computador e altera o meu IDE. Eu não sei  se é algo que eu estou fazendo errado, ou se é “zoeira” desse cara que me persegue. 
Se alguém puder tentar me ajudar, eu agradeço.
O programa está todo comentado e também está com vários  “marcadores”   que eu fiz procurando  erros.
Outra coisa. O programa é para ser feito utilizando somente vetores.  Nesta parte do livro ainda não se chegou  em  struct ,filas ou ponteiros.
Eu fiz um programa em um bloco único. Assim que ele estiver rodando eu o divido em funções. 
Desde já os meus agradecimentos. 
.
Enunciado:
Um dos problemas mais interessantes para os  fãs do jogo de xadrez é o problema do Passeio do Cavalo proposto originalmente pelo matemático Euler.
A questão é esta: a peça do jogo de xadrez  chamada cavalo pode mover ao longo de um tabuleiro vazio e passar uma única vez em cada uma das 64 casas.
O cavalo faz movimentos em formato de  ”L” (percorre duas casas em  uma direção  e uma no sentido perpendicular às duas primeiras. Dessa forma de uma casa no meio do tabuleiro, o cavalo pode fazer 8 movimentos diferentes, ou seja, ele pode se movimentar:
Movimento 1. Mover 2 posições à direita e 1 para baixo;
Movimento 2.  Mover 1 posição à direita e 2 para baixo;
Movimento 3. Mover 2 posições à direita e 1 para cima;
Movimento 4. Mover 1 posição à direita e 2 para cima;
Desenvolva um programa que moverá o cavalo pelo tabuleiro de xadrez. O tabuleiro em si é representado  pelo array bidimensional  8-por-8 tabuleiro.
Cada um dos quadrados(casas) é inicializado com o valor zero.
Utilize um contador que varie de 1 à 64.
Lembre-se de testar cada movimento potencial para se certificar de que o cavalo não está saindo do tabuleiro.
Os quadrados estão classificados de acordo com a sua acessibilidade pelo vetor tabuleiro2  onde deve-se mover o cavalo(dentro dos movimentos  em forma de “L”) para o quadrado que seja mais inacessível. Os números  do vetor tabuleiro2 indicam a partir de quantos quadrados um determinado quadrado pode ser acessado.
O cavalo deve se mover para o quadrado com menor número de acessibilidade. Em caso de empate o   cavalo pode se mover para qualquer um dos quadrados que empataram. 
Até aqui eu fiz.
.
Só que a continuação do exercício pede que agora o exercício seja modificado de modo a que  quando houver um empate entre  dois ou mais quadrados a escolha seja feita verificando os quadrados que podem ser alcançados a partir dos quadrados empatados. O programa deve fazer o movimento do cavalo para o quadrado para o qual o próximo movimento levar ao quadrado com menor número de acessibilidade. 
Por exemplo:
Eu preenchi um quadrado e no próximo movimento existem duas posições que eu posso acessar de onde estou. O programa deve verificar qual das duas posições possui um número menor  no vetor tabuleiro2. 

.

#include <stdio.h>
#include <stdlib.h>
#include <locale.h>
#include <windows.h>
#define TAMANHO 8
void imprime(int a[TAMANHO][TAMANHO]);

int main()
{
    int i,j,tabuleiro[TAMANHO][TAMANHO]={0};
    static int x2,y2,num1=0,num2=0,movimento2=1,cont30=2,cont4=0,cont6=0;
    static int x=0,y=0,cont=0,cont2=0,cont3=0,cont20=2,movimento=1,vetor[TAMANHO][TAMANHO]={0};
    static int tabuleiro2[TAMANHO][TAMANHO]= {{2,3,4,4,4,4,3,2},
                                              {3,4,6,6,6,6,4,3},
                                              {4,6,8,8,8,8,6,4},
                                              {4,6,8,8,8,8,6,4},
                                              {4,6,8,8,8,8,6,4},
                                              {4,6,8,8,8,8,6,4},
                                              {3,4,6,6,6,6,4,3},
                                              {2,3,4,4,4,4,3,2}};
    setlocale(LC_ALL,"");
    while(cont<64){
        printf(" 1. Mover 2 posições à direita e 1 para baixo\n");
        printf(" 2. Mover 1 posição à direita e 2 para baixo\n");
        printf(" 3. Mover 2 posições à direita e 1 para cima\n");
        printf(" 4. Mover 1 posição à direita e 2 para cima\n");
        printf(" 5. Mover 2 posições à esquerda e 1 para cima\n");
        printf(" 6. Mover 2 posições à esquerda e 1 para baixo\n");
        printf(" 7. Mover 1 posição à esquerda e 2 para cima\n");
        printf(" 8. Mover 1 posição à esquerda e 2 para baixo\n");

        if(movimento==1){
            x=x+1;                  //Testa  o movimento 1
            if(x>=TAMANHO)          //Verifica se a linha
                cont2++;            //pertence ao tabuleiro
            y=y+2;
            printf("1. x= %d  y= %d\n",x,y);
            if(y>=TAMANHO)       //Verifica se a coluna
                cont2++;        //pertence ao tabuleiro
            if(cont2==0 && tabuleiro[x][y]==0){//Verifica se a posição está vazia
                if(tabuleiro2[x][y]==cont20){ //verifica se nessa posição está
                    vetor[x][y]=cont20;       //o menor valor do vetor
                    tabuleiro[x][y]=cont;   //Adiciona este movimento ao vetor
                    cont++;
                    num1=x;            //cont20 ´começa do menos valor
                    num2=y;            //que é 2 e vai até 8
                    cont3++;           // que são as posições do tabuleiro2
                }                      //cont3 conta quantas posições ue servem
            }                           //foram encontradas
            x=x-1;          //x w y retornam ao valor anterior
            y=y-2;          //para continuar a busca
            cont2=0;
            movimento++;
            printf("1. x= %d  y= %d\n",x,y);
            printf("cont20= %d\n",cont20);
            printf("cont3= %d\n\n",cont3);
        }

        if(movimento==2){
            x=x+2;
            if(x>=TAMANHO)
                cont2++;
            y=y+1;
            printf("2. x= %d  y= %d\n",x,y);
            if(y>=TAMANHO)
                cont2++;
            if(cont2==0 && tabuleiro[x][y]==0){
                if(tabuleiro2[x][y]==cont20){
                    vetor[x][y]=cont20;
                    tabuleiro[x][y]=cont;
                    cont++;
                    num1=x;
                    num2=y;
                    cont3++;
                }
            }
            x=x-2;
            y=y-1;
            cont2=0;
            movimento++;
            printf("2. x= %d  y= %d\n",x,y);
            printf("cont20= %d\n",cont20);
            printf("cont3= %d\n\n",cont3);
        }

        if(movimento==3){
            x=x-1;
            if(x<0)
                cont2++;
            y=y+2;
            printf("3. x= %d  y= %d\n",x,y);
            if(y>=TAMANHO)
                cont2++;
            if(cont2==0 && tabuleiro[x][y]==0){
                if(tabuleiro2[x][y]==cont20){
                    vetor[x][y]=cont20;
                    tabuleiro[x][y]=cont;
                    cont++;
                    num1=x;
                    num2=y;
                    cont3++;
                }
            }
            x=x+1;
            y=y-2;
            cont2=0;
            movimento++;
            printf("3. x= %d  y= %d\n",x,y);
            printf("cont20= %d\n",cont20);
            printf("cont3= %d\n\n",cont3);
        }

        if(movimento==4){
            x=x-2;
            if(x<0)
                cont2++;
            y=y+1;
            printf("4. x= %d  y= %d\n",x,y);
            if(y>=TAMANHO)
                cont2++;
            if(cont2==0 && tabuleiro[x][y]==0){
                if(tabuleiro2[x][y]==cont20){
                    vetor[x][y]=cont20;
                    tabuleiro[x][y]=cont;
                    cont++;
                    num1=x;
                    num2=y;
                    cont3++;
                }
            }
            x=x+2;
            y=y-1;
            cont2=0;
            movimento++;
            printf("4. x= %d  y= %d\n",x,y);
            printf("cont20= %d\n",cont20);
            printf("cont3= %d\n\n",cont3);
        }

        if(movimento==5){
            x=x-1;
            if(x<0)
                cont2++;
            y=y-2;
            printf("5. x= %d  y= %d\n",x,y);
            if(y<0)
                cont2++;
            if(cont2==0 && tabuleiro[x][y]==0){
                if(tabuleiro2[x][y]==cont20){
                    vetor[x][y]=cont20;
                    tabuleiro[x][y]=cont;
                    cont++;
                    num1=x;
                    num2=y;
                    cont3++;
                }
            }
            x=x+1;
            y=y+2;
            cont2=0;
            movimento++;
            printf("5. x= %d  y= %d\n",x,y);
            printf("cont20= %d\n",cont20);
            printf("cont3= %d\n\n",cont3);
        }

        if(movimento==6){
            x=x+1;
            if(x>=TAMANHO)
                cont2++;
            y=y-2;
            printf("6. x= %d  y= %d\n",x,y);
            if(y<0)
                cont2++;
            if(cont2==0 && tabuleiro[x][y]==0){
                if(tabuleiro2[x][y]==cont20){
                    vetor[x][y]=cont20;
                    tabuleiro[x][y]=cont;
                    cont++;
                    num1=x;
                    num2=y;
                    cont3++;
                }
            }
            x=x-1;
            y=y+2;
            cont2=0;
            movimento++;
            printf("6. x= %d  y= %d\n",x,y);
            printf("cont20= %d\n",cont20);
            printf("cont3= %d\n\n",cont3);
        }

        if(movimento==7){
            x=x-2;
            if(x<0)
                cont2++;
            y=y-1;
            printf("7. x= %d  y= %d\n",x,y);
            if(y<0)
                cont2++;
            if(cont2==0 && tabuleiro[x][y]==0){
                if(tabuleiro2[x][y]==cont20){
                    vetor[x][y]=cont20;
                    tabuleiro[x][y]=cont;
                    cont++;
                    num1=x;
                    num2=y;
                    cont3++;
                }
            }
            x=x+2;
            y=y+1;
            cont2=0;
            movimento++;
            printf("7. x= %d  y= %d\n",x,y);
            printf("cont20= %d\n",cont20);
            printf("cont3= %d\n\n",cont3);
        }

        if(movimento==8){
            x=x+2;
            if(x>=TAMANHO)
                cont2++;
            y=y-1;
            printf("8. x= %d  y= %d\n",x,y);
            if(y<0)
                cont2++;
            if(cont2==0 && tabuleiro[x][y]==0){
                if(tabuleiro2[x][y]==cont20){
                    vetor[x][y]=cont20;
                    tabuleiro[x][y]=cont;
                    cont++;
                    num1=x;
                    num2=y;
                    cont3++;
                }
            }
            x=x-2;
            y=y+1;
            cont2=0;
            movimento++;
            printf("8. x= %d  y= %d\n",x,y);
            printf("cont20= %d\n",cont20);
            printf("cont3= %d\n\n",cont3);
        }


        if(cont3==0){
            if(cont20==8)       //Se cont3==0 significa que
                cont20=2;       //nenhuma posição é igual a
            else                //cont20.
                cont20++;
        }
        if(cont3==1){
            x=num1;
            y=num2;
            for(i=0;i<TAMANHO;i++){
                for(j=0;j<TAMANHO;j++){
                    vetor[x][y]=0;
                }
            }
            cont20=2;
            cont3=0;
        }
        if(cont3>1){
            //cont=cont-cont3+1;
            printf("Maior que 1\n");
            movimento2=1;
            while(cont30<8){
                for(i=0;i<TAMANHO;i++){
                    Sleep(100);
                    for(j=0;j<TAMANHO;j++){
                        cont6=0;
                        Sleep(100);
                        //*********
                        printf("\n\n*UM\n\n\n");
                        //*******
                        Sleep(100);
                        if(vetor[i][j]!=0){
                            movimento2=1;

                                printf("\n\nDOIS\n\n\n");
                                Sleep(100);

                            printf("vetor[%d][%d]= %d\n",i,j,vetor[i][j]);
                            printf("movimento2= %d\n",movimento2);
                            x2=i;
                            y2=j;
                             if(movimento2==1){
                                x2=x2+1;
                                if(x2>=TAMANHO)
                                    cont4++;
                                y2=y2+2;
                                printf("1. x2= %d  y2= %d\n",x2,y2);
                                if(y2>=TAMANHO)
                                    cont4++;
                                if(cont4==0 && tabuleiro[x2][y2]==0){
                                    if(tabuleiro2[x2][y2]==cont30){
                                        tabuleiro[x2][y2]=cont;
                                        cont++;
                                        num1=x2;
                                        num2=y2;
                                        x=i;
                                        y=j;
                                        cont6++;
                                        cont30=2;
                                        printf("\n\nAqui eu zero o  vetor nessa posição.\n");
                                        vetor[x2][y2]=0;
                                        printf("vetor = %d\n",vetor[x2][y2]);
                                        printf("Só que ao imprimir o vetor (abaixo) ele não aparece zerado\n");
                                        printf("Pelo menos no meu IDE ele não aparece zerado.\n\n");
                                        imprime(vetor);
                                        break;
                                    }
                                }
                                x2=x2-1;
                                y2=y2-2;
                                cont4=0;
                                movimento2++;
                                printf("1. x2= %d  y2= %d\n",x2,y2);
                                printf("cont30= %d\n",cont30);
                                printf("\n\nUm um\n\n\n");
                            }

                            if(movimento2==2){
                                x2=x2+2;
                                if(x2>=TAMANHO)
                                    cont4++;
                                y2=y2+1;
                                printf("2. x2= %d  y2= %d\n",x2,y2);
                                if(y2>=TAMANHO)
                                    cont4++;
                                if(cont4==0 && tabuleiro[x2][y2]==0){
                                    if(tabuleiro2[x2][y2]==cont30){
                                        vetor[x2][y2]=cont30;
                                        tabuleiro[x2][y2]=cont;
                                        cont++;
                                        num1=x2;
                                        num2=y2;
                                        x=i;
                                        y=j;
                                        cont6++;
                                        cont30=2;
                                        printf("\n\nAqui eu zero o  vetor nessa posição.\n");
                                        vetor[x2][y2]=0;
                                        printf("vetor = %d\n",vetor[x2][y2]);
                                        printf("Só que ao imprimir o vetor (abaixo) ele não aparece zerado\n");
                                        printf("Pelo menos no meu IDE ele não aparece zerado.\n\n");
                                        imprime(vetor);
                                        break;
                                    }
                                }
                                x2=x2-2;
                                y2=y2-1;
                                cont4=0;
                                movimento2++;
                                printf("2. x2= %d  y2= %d\n",x2,y2);
                                printf("cont30= %d\n",cont30);
                                printf("Dois dois\n\n\n");
                            }

                            if(movimento2==3){
                                x2=x2-1;
                                if(x2<0)
                                    cont4++;
                                y2=y2+2;
                                printf("3. x2= %d  y2= %d\n",x2,y2);
                                if(y2>=TAMANHO)
                                    cont4++;
                                if(cont4==0 && tabuleiro[x2][y2]==0){
                                    if(tabuleiro2[x2][y2]==cont20){
                                        tabuleiro[x2][y2]=cont;
                                        cont++;
                                        num1=x2;
                                        num2=y2;
                                        x=i;
                                        y=j;
                                        cont6++;
                                        cont30=2;
                                        printf("\n\nAqui eu zero o  vetor nessa posição.\n");
                                        vetor[x2][y2]=0;
                                        printf("vetor = %d\n",vetor[x2][y2]);
                                        printf("Só que ao imprimir o vetor (abaixo) ele não aparece zerado\n");
                                        printf("Pelo menos no meu IDE ele não aparece zerado.\n\n");
                                        imprime(vetor);
                                        break;
                                    }
                                }
                                x2=x2+1;
                                y2=y2-2;
                                cont4=0;
                                movimento2++;
                                printf("3. x2 %d  y2= %d\n",x2,y2);
                                printf("cont30= %d\n",cont30);
                                printf("Tres tres\n\n\n");
                            }

                            if(movimento2==4){
                                x2=x2-2;
                                if(x2<0)
                                    cont4++;
                                y2=y2+1;
                                printf("4. x2= %d  y2= %d\n",x2,y2);
                                if(y2>=TAMANHO)
                                    cont4++;
                                if(cont4==0 && tabuleiro[x2][y2]==0){
                                    if(tabuleiro2[x2][y2]==cont30){
                                        tabuleiro[x2][y2]=cont;
                                        cont++;
                                        num1=x2;
                                        num2=y2;
                                        x=i;
                                        y=j;
                                        cont6++;
                                        cont30=2;
                                        printf("\n\nAqui eu zero o  vetor nessa posição.\n");
                                        vetor[x2][y2]=0;
                                        printf("vetor = %d\n",vetor[x2][y2]);
                                        printf("Só que ao imprimir o vetor (abaixo) ele não aparece zerado\n");
                                        printf("Pelo menos no meu IDE ele não aparece zerado.\n\n");
                                        imprime(vetor);
                                        break;
                                    }
                                }
                                x2=x2+2;
                                y2=y2-1;
                                cont4=0;
                                movimento2++;
                                printf("4. x2= %d  y2= %d\n",x2,y2);
                                printf("cont30= %d\n",cont30);
                                printf("Quatro quatro\n\n\n");
                               }

                            if(movimento2==5){
                                x2=x2-1;
                                if(x2<0)
                                    cont4++;
                                y2=y2-2;
                                printf("5. x2= %d  y2= %d\n",x2,y2);
                                if(y2<0)
                                    cont4++;
                                if(cont4==0 && tabuleiro[x2][y2]==0){
                                    if(tabuleiro2[x2][y2]==cont30){
                                        tabuleiro[x2][y2]=cont;
                                        cont++;
                                        num1=x;
                                        num2=y;
                                        x=i;
                                        y=j;
                                        cont6++;
                                        cont30=2;
                                        printf("\n\nAqui eu zero o  vetor nessa posição.\n");
                                        vetor[x2][y2]=0;
                                        printf("vetor = %d\n",vetor[x2][y2]);
                                        printf("Só que ao imprimir o vetor (abaixo) ele não aparece zerado\n");
                                        printf("Pelo menos no meu IDE ele não aparece zerado.\n\n");
                                        imprime(vetor);
                                        break;
                                    }
                                }
                                x2=x2+1;
                                y2=y2+2;
                                cont4=0;
                                movimento2++;
                                printf("5. x2= %d  y2= %d\n",x2,y2);
                                printf("cont30= %d\n",cont30);
                                printf("Cinco cinco\n\n\n");
                            }

                            if(movimento2==6){
                                x2=x2+1;
                                if(x2>=TAMANHO)
                                    cont4++;
                                y2=y2-2;
                                printf("6. x2= %d  y2= %d\n",x2,y2);
                                if(y2<0)
                                    cont4++;
                                if(cont4==0 && tabuleiro[x2][y2]==0){
                                    if(tabuleiro2[x2][y2]==cont30){
                                        tabuleiro[x2][y2]=cont;
                                        cont++;
                                        num1=x;
                                        num2=y;
                                        x=i;
                                        y=j;
                                        cont6++;
                                        cont30=2;
                                        printf("\n\nAqui eu zero o  vetor nessa posição.\n");
                                        vetor[x2][y2]=0;
                                        printf("vetor = %d\n",vetor[x2][y2]);
                                        printf("Só que ao imprimir o vetor (abaixo) ele não aparece zerado\n");
                                        printf("Pelo menos no meu IDE ele não aparece zerado.\n\n");
                                        imprime(vetor);
                                        break;
                                    }
                                }
                                x2=x2-1;
                                y2=y2+2;
                                cont4=0;
                                movimento2++;
                                printf("6. x2= %d  y2= %d\n",x2,y2);
                                printf("cont30= %d\n",cont30);
                                printf("Seis seis\n\n\n");
                            }

                            if(movimento2==7){
                                x2=x2-2;
                                if(x2<0)
                                    cont4++;
                                y2=y2-1;
                                printf("7. x2= %d  y2= %d\n",x2,y2);
                                if(y2<0)
                                    cont4++;
                                if(cont4==0 && tabuleiro[x2][y2]==0){
                                    if(tabuleiro2[x2][y2]==cont30){
                                        tabuleiro[x2][y2]=cont;
                                        cont++;
                                        num1=x;
                                        num2=y;
                                        x=i;
                                        y=j;
                                        cont6++;
                                        cont30=2;
                                        printf("\n\nAqui eu zero o  vetor nessa posição.\n");
                                        vetor[x2][y2]=0;
                                        printf("vetor = %d\n",vetor[x2][y2]);
                                        printf("Só que ao imprimir o vetor (abaixo) ele não aparece zerado\n");
                                        printf("Pelo menos no meu IDE ele não aparece zerado.\n\n");
                                        imprime(vetor);
                                        break;
                                    }
                                }
                                x2=x2+2;
                                y2=y2+1;
                                cont4=0;
                                movimento2++;
                                printf("7. x2= %d  y2= %d\n",x2,y2);
                                printf("cont30= %d\n",cont30);
                                printf("Sete sete\n\n\n");
                            }

                            if(movimento2==8){
                                x2=x2+2;
                                if(x2>=TAMANHO)
                                    cont4++;
                                y2=y2-1;
                                printf("8. x2= %d  y2= %d\n",x2,y2);
                                if(y2<0)
                                    cont4++;
                                if(cont4==0 && tabuleiro[x2][y2]==0){
                                    if(tabuleiro2[x2][y2]==cont30){
                                        tabuleiro[x2][y2]=cont;
                                        cont++;
                                        num1=x;
                                        num2=y;
                                        x=i;
                                        y=j;
                                        cont6++;
                                        cont30=2;
                                       printf("\n\nAqui eu zero o  vetor nessa posição.\n");
                                        vetor[x2][y2]=0;
                                        printf("vetor = %d\n",vetor[x2][y2]);
                                        printf("Só que ao imprimir o vetor (abaixo) ele não aparece zerado\n");
                                        printf("Pelo menos no meu IDE ele não aparece zerado.\n\n");
                                        imprime(vetor);
                                        break;
                                    }
                                }
                                x2=x2-2;
                                y2=y2+1;
                                cont4=0;
                                movimento2++;
                                printf("8. x2= %d  y2= %d\n",x2,y2);
                                printf("cont30= %d\n",cont30);
                                printf("Oito oito\n\n\n");
                            }
                        }
                    }
                     if(cont6==1){      //cont6==1 significa que o
                for(i=0;i<TAMANHO;i++){ //programa já encontrou um valor
                    for(j=0;j<TAMANHO;j++){  //Estou zerando o vetor novamente
                        vetor[x][y]=0;      //para armazenar novos valores
                                            //Só que não zera
                                            //Não entendo o porquê
                    }
                }
                break;      //Saindo do for
                }
                }
              if(cont6==1){
                for(i=0;i<TAMANHO;i++){     //zerando o vetor novamente
                    for(j=0;j<TAMANHO;j++){ // Novamente Não zera
                        vetor[x][y]=0;
                    }
                }
                break;      //Saindo do while
                }
                cont30++;  //mesma função do cont20
            }               //na primeira parte do programa
                        }
                        cont3=0;
                        movimento=1;
                        imprime(tabuleiro);
                    }
}

void imprime(int a[TAMANHO][TAMANHO]){
    int i,j;

    printf("\n\n\n");
    for(i=0;i<TAMANHO;i++){
        for(j=0;j<TAMANHO;j++){
            printf("%3d",a[i][j]);
            Sleep(100);
        }
        printf("\n\n");
    }
    printf("\n\n\n");
}

 

 

 

Eu consegui resolver vou postar aqui, talvez ajude alguém.

#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include <locale.h>
#define TAMANHO 8
void imprime(int a[TAMANHO][TAMANHO]);

int main()
{
    int i,j,cont=1,movimento=1,movimento2=1,cont2=0,cont4=0,cont6=0,num1,num2;
    static int x=0,y=0,cont3=0,cont20=2,cont30=2,vetor[TAMANHO][TAMANHO]={0},tabuleiro[TAMANHO][TAMANHO]={0};
    static int tabuleiro2[TAMANHO][TAMANHO]= {{2,3,4,4,4,4,3,2},
                                              {3,4,6,6,6,6,4,3},
                                              {4,6,8,8,8,8,6,4},
                                              {4,6,8,8,8,8,6,4},
                                              {4,6,8,8,8,8,6,4},
                                              {4,6,8,8,8,8,6,4},
                                              {3,4,6,6,6,6,4,3},
                                              {2,3,4,4,4,4,3,2}};
    setlocale(LC_ALL,"");
    while(cont<=64){
        printf(" 1. Mover 2 posições à direita e 1 para baixo\n");
        printf(" 2. Mover 1 posição à direita e 2 para baixo\n");
        printf(" 3. Mover 2 posições à direita e 1 para cima\n");
        printf(" 4. Mover 1 posição à direita e 2 para cima\n");
        printf(" 5. Mover 2 posições à esquerda e 1 para cima\n");
        printf(" 6. Mover 2 posições à esquerda e 1 para baixo\n");
        printf(" 7. Mover 1 posição à esquerda e 2 para cima\n");
        printf(" 8. Mover 1 posição à esquerda e 2 para baixo\n");

        if(movimento==1){
            x=x+1;
            if(x>TAMANHO-1)       //Verifica se x está dentro do tabuleiro
                cont2++;
            y=y+2;              //Verifica se y está dentro do  tabuleiro
            if(y>TAMANHO-1)
                cont2++;
            if(cont2==0 && tabuleiro[x][y]==0){   //Verifica se a posição(x,y) está vazia
                if(tabuleiro2[x][y]==cont20){     //Verifica se a posição é igual ao valor buscado no momento
                    vetor[x][y]=cont20;
                    num1=x;
                    num2=y;    //Coloca a posição (x,y) no vetor
                    cont3++;   //conta quantas posição são válidas
                    }
            }
            x=x-1;
            y=y-2;
            cont2=0;
            movimento++;      //cont20 --> está procurando uma posição (x,y) no vetor tabuleiro2
            printf("\n\ncont20= %d\n",cont20);  //que seja igual a cont20
            printf("cont3= %d\n",cont3);        //cont3==0 nao encontrou nenhuma posição
        }                                       //cont3==1 encontropu somente uma posição
                                                //cont3>1 encontrou várias posições
        if(movimento==2){
            x=x+2;
            if(x>TAMANHO-1)
                cont2++;
            y=y+1;
            if(y>TAMANHO-1)
                cont2++;
            if(cont2==0 && tabuleiro[x][y]==0){
                if(tabuleiro2[x][y]==cont20){
                    vetor[x][y]=cont20;
                    num1=x;
                    num2=y;
                    cont3++;
                }
            }
            x=x-2;
            y=y-1;
            cont2=0;
            movimento++;
            printf("cont20= %d\n",cont20);
            printf("cont3= %d\n",cont3);
        }
        if(movimento==3){
            x=x-1;
            if(x<0)
                cont2++;
            y=y+2;
            if(y>TAMANHO-1)
                cont2++;
            if(cont2==0 && tabuleiro[x][y]==0){
                if(tabuleiro2[x][y]==cont20){
                    vetor[x][y]=cont20;
                    num1=x;
                    num2=y;
                    cont3++;
                }
            }
            x=x+1;
            y=y-2;
            cont2=0;
            movimento++;
            printf("cont20= %d\n",cont20);
            printf("cont3= %d\n",cont3);
        }

        if(movimento==4){
            x=x-2;
            if(x<0)
                cont2++;
            y=y+1;
            if(y>TAMANHO-1)
                cont2++;
            if(cont2==0 && tabuleiro[x][y]==0){
                if(tabuleiro2[x][y]==cont20){
                    vetor[x][y]=cont20;
                    num1=x;
                    num2=y;
                    cont3++;
                }
            }
            x=x+2;
            y=y-1;
            cont2=0;
            movimento++;
            printf("cont20= %d\n",cont20);
            printf("cont3= %d\n",cont3);
        }
        if(movimento==5){
            x=x-1;
            if(x<0)
                cont2++;
            y=y-2;
            if(y<0)
                cont2++;
            if(cont2==0 && tabuleiro[x][y]==0){
                if(tabuleiro2[x][y]==cont20){
                    vetor[x][y]=cont20;
                    num1=x;
                    num2=y;
                    cont3++;
                }
            }
            x=x+1;
            y=y+2;
            cont2=0;
            movimento++;
            printf("cont20= %d\n",cont20);
            printf("cont3= %d\n",cont3);
        }

        if(movimento==6){
            x=x+1;
            if(x>TAMANHO-1)
                cont2++;
            y=y-2;
            if(y<0)
                cont2++;
            if(cont2==0 && tabuleiro[x][y]==0){
                if(tabuleiro2[x][y]==cont20){
                    vetor[x][y]=cont20;
                    num1=x;
                    num2=y;
                    cont3++;
                }
            }
            x=x-1;
            y=y+2;
            cont2=0;
            movimento++;
            printf("cont20= %d\n",cont20);
            printf("cont3= %d\n",cont3);
        }

        if(movimento==7){
            x=x-2;
            if(x<0)
                cont2++;
            y=y-1;
            if(y<0)
                cont2++;
            if(cont2==0 && tabuleiro[x][y]==0){
                if(tabuleiro2[x][y]==cont20){
                    vetor[x][y]=cont20;
                    num1=x;
                    num2=y;
                    cont3++;
                }
            }
            x=x+2;
            y=y+1;
            cont2=0;
            movimento++;
            printf("cont20= %d\n",cont20);
            printf("cont3= %d\n",cont3);
        }

        if(movimento==8){
            x=x+2;
            if(x>TAMANHO-1)
                cont2++;
            y=y-1;
            if(y<0)
                cont2++;
            if(cont2==0 && tabuleiro[x][y]==0){
                if(tabuleiro2[x][y]==cont20){
                    vetor[x][y]=cont20;
                    num1=x;
                    num2=y;
                    cont3++;
                }
            }
            x=x-2;
            y=y+1;
            cont2=0;
            movimento++;
            printf("cont20= %d\n",cont20);
            printf("cont3= %d\n",cont3);
        }
        if(cont20==8)
            cont20=2;
        if(cont3==0){
            printf("\ncont3=0 significa que não encontrou\n");
            printf("\tnenhum movimento que possa ser feito no tabuleiro2(vetor)\n");
            printf("\tneste momento");
        cont20++;
        }
        if(cont3==1){
            x=num1;
            y=num2;
            printf("\n\ncont3=1 significa que encontrou\n");
            printf("\tsomente uma movimento possível no tabuleiro2(vetor)\n");
            printf("num1= %d   num2= %d\n",num1,num2);
            tabuleiro[x][y]=cont;
            cont20=2;
            cont++;
        }
        if(cont3>1){
            printf("\ncont3>1 significa que encontrou\n");
            printf("\tmais de um movimento possível no tabuleiro2(vetor)\n");
            printf("\tAgora o programa vai procurar o movimento mais adequado\n\n");
            printf("num1= %d   num2= %d\n",num1,num2);
            Sleep(2200);
            while(cont30<=8){
                for(i=0;i<TAMANHO;i++){
                    for(j=0;j<TAMANHO;j++){
                        if(vetor[i][j]!=0){
                            x=i;
                            y=j;
                            if(movimento2==1){
                                x=x+1;
                                if(x>TAMANHO-1)  //Verifica se x está dentro do tabuleiro
                                    cont4++;
                                y=y+2;           //Verifica se y está dentro do  tabuleiro
                                if(y>TAMANHO-1)
                                    cont4++;
                                if(cont4==0 && tabuleiro[x][y]==0){  //Verifica se a posição(x,y) está vazia
                                    if(tabuleiro2[x][y]==cont30){    //Verifica se a posição é igual ao valor buscado no momento
                                        num1=i;
                                        num2=j;
                                        cont6++;
                                        break;
                                        }
                                }
                                x=x-1;
                                y=y-2;
                                cont4=0;
                                movimento2++;
                                printf("cont30= %d\n",cont30);
                                printf("cont3= %d\n",cont3);
                            }

                            if(movimento2==2){
                                x=x+2;
                                if(x>TAMANHO-1)
                                    cont4++;
                                y=y+1;
                                if(y>TAMANHO-1)
                                    cont4++;
                                if(cont4==0 && tabuleiro[x][y]==0){
                                    if(tabuleiro2[x][y]==cont30){
                                        num1=i;
                                        num2=j;
                                        cont6++;
                                        break;
                                    }
                                }
                                x=x-2;
                                y=y-1;
                                cont4=0;
                                movimento2++;
                                printf("cont30= %d\n",cont30);
                                printf("cont3= %d\n",cont3);
                            }
                            if(movimento2==3){
                                x=x-1;
                                if(x<0)
                                    cont4++;
                                y=y+2;
                                if(y>TAMANHO-1)
                                    cont4++;
                                if(cont4==0 && tabuleiro[x][y]==0){
                                    if(tabuleiro2[x][y]==cont30){
                                        num1=i;
                                        num2=j;
                                        cont6++;
                                        break;
                                    }
                                }
                                x=x+1;
                                y=y-2;
                                cont4=0;
                                movimento2++;
                                printf("cont30= %d\n",cont30);
                                printf("cont3= %d\n",cont3);
                            }

                            if(movimento2==4){
                                x=x-2;
                                if(x<0)
                                    cont4++;
                                y=y+1;
                                if(y>TAMANHO-1)
                                    cont4++;
                                if(cont4==0 && tabuleiro[x][y]==0){
                                    if(tabuleiro2[x][y]==cont30){
                                        num1=i;
                                        num2=j;
                                        cont6++;
                                        break;
                                    }
                                }
                                x=x+2;
                                y=y-1;
                                cont2=0;
                                movimento2++;
                                printf("cont30= %d\n",cont30);
                                printf("cont3= %d\n",cont3);
                            }
                            if(movimento2==5){
                                x=x-1;
                                if(x<0)
                                    cont4++;
                                y=y-2;
                                if(y<0)
                                    cont4++;
                                if(cont4==0 && tabuleiro[x][y]==0){
                                    if(tabuleiro2[x][y]==cont30){
                                        num1=i;
                                        num2=j;
                                        cont6++;
                                        break;
                                    }
                                }
                                x=x+1;
                                y=y+2;
                                cont4=0;
                                movimento2++;
                                printf("cont30= %d\n",cont30);
                                printf("cont3= %d\n",cont3);
                            }

                            if(movimento2==6){
                                x=x+1;
                                if(x>TAMANHO-1)
                                    cont4++;
                                y=y-2;
                                if(y<0)
                                    cont4++;
                                if(cont4==0 && tabuleiro[x][y]==0){
                                    if(tabuleiro2[x][y]==cont30){
                                        num1=i;
                                        num2=j;
                                        cont6++;
                                        break;
                                    }
                                }
                                x=x-1;
                                y=y+2;
                                cont4=0;
                                movimento2++;
                                printf("cont30= %d\n",cont30);
                                printf("cont3= %d\n",cont3);
                            }

                            if(movimento2==7){
                                x=x-2;
                                if(x<0)
                                    cont4++;
                                y=y-1;
                                if(y<0)
                                    cont4++;
                                if(cont4==0 && tabuleiro[x][y]==0){
                                    if(tabuleiro2[x][y]==cont30){
                                        num1=i;
                                        num2=j;
                                        cont6++;
                                        break;
                                    }
                                }
                                x=x+2;
                                y=y+1;
                                cont4=0;
                                movimento2++;
                                printf("cont30= %d\n",cont30);
                                printf("cont3= %d\n",cont3);
                            }

                            if(movimento2==8){
                                x=x+2;
                                if(x>TAMANHO-1)
                                    cont4++;
                                y=y-1;
                                if(y<0)
                                    cont4++;
                                if(cont4==0 && tabuleiro[x][y]==0){
                                    if(tabuleiro2[x][y]==cont30){
                                        num1=i;
                                        num2=j;
                                        cont6++;
                                        break;
                                    }
                                }
                                x=x-2;
                                y=y+1;
                                cont4=0;
                                movimento2++;
                                printf("cont30= %d\n",cont30);
                                printf("cont3= %d\n",cont3);
                            }
                        }
                    }
                    if(cont6==1)
                        break;
                }
                if(cont6==1)
                    break;
                cont30++;
                movimento2=1;
            }
            x=num1;
            y=num2;
            tabuleiro[x][y]=cont;
            cont++;
            for(i=0;i<TAMANHO;i++){
                for(j=0;j<TAMANHO;j++){
                    vetor[i][j]=0;
                }
            }
            cont20=2;
        }
        imprime(tabuleiro);
        movimento=1;
        cont3=0;
        num1=-1;
        num2=-1;
    }
    return 0;
}

void imprime(int a[TAMANHO][TAMANHO]){
    int i,j;

    printf("\n\n");
    for(i=0;i<TAMANHO;i++){
        for(j=0;j<TAMANHO;j++){
            printf("%3d",a[i][j]);
            Sleep(100);
        }
        printf("\n\n");
    }
    Sleep(1000);
    printf("\n\n");
}

 

 

[arfneto]

 Bom que resolveu. Não respondeu a nada do que eu perguntei, nem mudou nada do que eu sugeri, mas é possível ir por esse caminho.

Ainda não entendei como vai funcionar seu programa. Imagino que o esperado seria dar uma posição de início e o programa gerar a sequência de movimentos até as 64 casas ou até onde der, já que só pode passar uma vez por cada casa. 

 

Seria legar salvar o caminho para mostrar no fim, mesmo que não desenhasse o caminho na tela. Um array de 64 posições claro seria o suficiente. E podia colocar no tabuleiro os números de 1 até o total de movimentos que conseguiu.
 

  sobre esse método
 

Citação

Em 1823, H.C. Warnsdorff propôs um interessante e muito prático; a cada salto deve-se mover o cavalo para uma casa que lhe dê o menor número de alternativas para o salto seguinte. 

Leia mais em: https://super.abril.com.br/comportamento/o-percurso-do-cavalo-no-xadrez/

Como eu disse antes, não é preciso testar os movimentos toda vez, já que eles são bem conhecidos. Basta uma tabela com eles. Sempre vai fazer os mesmos movimentos. Só complica repetir isso toda vez...

 

Um exemplo

 

#define	_T_ 8
char	n_mov[_T_][_T_] = { 0 };
char	poss[_T_][_T_][_T_] = { 0 };

 

Eu testei algo assim, e funciona bem. n_mov[ ][ ] tem os possíveis movimentos para cada posição, e a tabela pss[ ][ ][ ] tem os possíveis movimentos, tudo calculado uma vez só. n_mov é o que você chamou de tabuleiro2 . poss também é constante mas é chato de digitar: o simples seria escrever um programa para calcular uma vez e gravar  em um arquivo. Não fiz isso porque de todo modo o "cálculo" é muito simples. 

 

Preenchendo as duas tabelas, uma vez só no programa:
 

int         carga_tabela()
{
    char    mov = 0;
    for (char l = 0; l < _T_; l += 1)
    {
        for (char c = 0; c < _T_; c += 1)
        {
            mov = 0;
            // tenta o Norte: sobe
            if (l > 1)
            {   // se 0 ou 1 nao da pra subir
                if (c > 0)
                {   // NO ok esquerda
                    poss[l][c][mov] = (l - 2) * 16 + (c - 1);
                    mov += 1;
                }
                if (c < 7)
                {   // NE OK direita
                    poss[l][c][mov] = (l - 2) * 16 + (c + 1);
                    mov += 1;
                }
            };
            // tenta o Sul: desce
            if (l < 6)
            {   // se 6 ou 7 nao da pra descer
                if (c > 0)
                {   // SO ok: esquerda
                    poss[l][c][mov] = (l + 2) * 16 + (c - 1);
                    mov += 1;
                }
                if (c < 7)
                {   // SE OK: direita
                    poss[l][c][mov] = (l + 2) * 16 + (c + 1);
                    mov += 1;
                }
            };
            // tenta o Oeste: esquerda
            if (c > 1)
            {   // se 0 ou 1 nao da pra subir
                if (l > 0)
                {   // NO ok
                    poss[l][c][mov] = (l - 1) * 16 + (c - 2);
                    mov += 1;
                }
                if (l < 7)
                {   // SO OK
                    poss[l][c][mov] = (l + 1) * 16 + (c - 2);
                    mov += 1;
                }
            };
            // tenta o Leste: direita
            if (c < 6)
            {   // se 6 ou 7 nada de subir
                if (l > 0)
                {   // NE ok: sobe
                    poss[l][c][mov] = (l - 1) * 16 + (c + 2);
                    mov += 1;
                }
                if (l < 7)
                {   // SE OK
                    poss[l][c][mov] = (l + 1) * 16 + (c + 2);
                    mov += 1;
                }
            };  // if()
            n_mov[l][c] = mov;
        };  // for()
    };  // for()
    return 0;
};  // if()

 

Uma pequena mudança na impressão também ajuda:
 

void imprime(char a[_T_][_T_], const char* msg)
{
    if (msg != NULL)
        printf("\n%s\n", msg);
    else
        printf("\n");
    for ( int i = 0; i < _T_; i++ )
    {
        for (int j = 0; j < _T_; j++)
            if (a[i][j] != 0)
            {
                if (a[i][j] > 8)
                    printf("  C");
                else
                    printf("%3d", a[i][j]);
            }
            else
            {
                printf("  .");
            };  
        printf("\n");
    }
    printf("\n");
}

 

Porque ajuda?

 

porque não ajuda nada mostrar os zeros, fica melhor trocando por um ponto, e mostrar a posição do cavalo é util. E poder colocar um título ajuda nos testes e no uso do programa...

 

Exemplo de Saída:

 

Entre com linha e coluna: 1 4

Movimentos com o cavalo em 'C'

  .  .  3  .  .  .  5  .
  .  .  .  .  C  .  .  .
  .  .  4  .  .  .  6  .
  .  .  .  1  .  2  .  .
  .  .  .  .  .  .  .  .
  .  .  .  .  .  .  .  .
  .  .  .  .  .  .  .  .
  .  .  .  .  .  .  .  .


Possiveis movimentos em cada destino

  .  .  4  .  .  .  3  .
  .  .  .  .  C  .  .  .
  .  .  8  .  .  .  6  .
  .  .  .  8  .  8  .  .
  .  .  .  .  .  .  .  .
  .  .  .  .  .  .  .  .
  .  .  .  .  .  .  .  .
  .  .  .  .  .  .  .  .

Menor numero de movimentos: 3 (0X repeticoes)

 

Escrevi só a lógica dos movimentos. Mas é o suficiente para a solução: a função retorna a posição mais adequada, mesmo quando há mais repetições, como esse

 

Entre com linha e coluna: 4 4

Movimentos com o cavalo em 'C'

  .  .  .  .  .  .  .  .
  .  .  .  .  .  .  .  .
  .  .  .  1  .  2  .  .
  .  .  5  .  .  .  7  .
  .  .  .  .  C  .  .  .
  .  .  6  .  .  .  8  .
  .  .  .  3  .  4  .  .
  .  .  .  .  .  .  .  .


Possiveis movimentos em cada destino

  .  .  .  .  .  .  .  .
  .  .  .  .  .  .  .  .
  .  .  .  8  .  8  .  .
  .  .  8  .  .  .  6  .
  .  .  .  .  C  .  .  .
  .  .  8  .  .  .  6  .
  .  .  .  6  .  6  .  .
  .  .  .  .  .  .  .  .

Menor numero de movimentos: 6 (3X repeticoes)
adiante(6,3): 6 movimentos
Min: 3 mov.
adiante(6,5): 6 movimentos
Min: 2 mov.
adiante(3,6): 6 movimentos
Min: 3 mov.
adiante(5,6): 6 movimentos
Min: 2 mov.

 

Usando a mesma função imprime() para colocar os destinos no tabuleiro ajuda a testar

 

Foi útil usar um char para guardar o movimento. Um char sem sinal permitira usar até 16 x 16. Como tem só 8x8 aqui está bem dentro da capacidade:
 

	
		L L L L C C C C
		0 1 2 3 4 5 6 7

 

E assim facilita as contas: para um certo char v,  _L(v) e _C(v) devolvem a linha e a coluna...
 

#define _L(v) ((v & 0xF0) >> 4) // a linha a partir de v
#define _C(v) ((v & 0x0F)) // e a coluna a partir de v

 

Se eu tiver tempo escrevo o resto se alguém se interessar