Olá! Eu desenvolvi um código bem estranho, mas funcional, pra resolver o exercício 7.22 do livro do Deitel Java: Como programar, que trata do Knights tour (Passeio do Cavalo), é um programa que simula um tabuleiro de xadrez vazio onde uma peça é colocada e fazendo apenas o movimento do cavalo (em “L”) se deve chegar a todas as casas apenas uma vez. eu ainda sou iniciante então não sei muito e esse problema envolve umas heurísticas meio pesadas pra mim. Eu dei uma pesquisada mas a única coisa que eu consegui encontrar foi a parte que eu já “resolvi”. Mas o que eu não consegui foi essa parte:
d) Escreva uma versão do aplicativo Passeio do Cavalo que, diante de um impasse entre dois ou mais quadrados, decide qual escolher vislumbrando os quadrados alcançáveis a partir daqueles geradores do impasse. Seu aplicativo deve mover para o quadrado empatado para o qual o próximo movimento chegaria a um quadrado com o número de acessibilidade mais baixo.
Pra tentar explicar um pouco: Existem dois arrays bidimensionais, um de booleans para saber quais casas o cavalo já visitou (true se sim, false se não), e outro chamado acessibility para informar quais são as casas mais importantes a serem visitadas, para que o programa seja “inteligente”, as casas mais importantes são as mais próximas dos cantos. a questão pede que quando o programa encontrar 2 ou mais casas igualmente importantes, ele possa escolher a melhor dentre elas. Eu acho que a forma que eu escrevi o programa dificultou um pouco as coisas estou bem perdido. Agradeço a ajuda 
Código:
import java.util.ArrayList;
public class PasseioDoCavalo{
private static int melhorScore = 8, melhorMovimento = 0;
private static String jogo = "Válido";
private static int currentRow, currentColumn, count = 0;
private static boolean[][] board = new boolean[8][8];
private static ArrayList<Integer> movsValidos = new ArrayList<>();
private static int[] horizontal = {2, 1, -1, -2, -2, -1, 1, 2};
private static int[] vertical = {-1, -2, -2, -1, 1, 2, 2, 1};
private static int[][] acessibility = {{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}};
public static void main(String[] args){
int contagem = 0;
for(int m = 0; m < 8; m++){
for(int n = 0; n < 8; n++){
currentRow = m; currentColumn = n; // primeira posição do cavalo
System.out.printf("Cavalo na posição do tabuleiro[%d][%d]%n", currentRow, currentColumn);
do{
board[currentRow][currentColumn] = true; // coloca a peça
count++; // atualiza a contagem
// percorre os oito possíveis movimentos
for(int moveNumber = 0; moveNumber < 8; moveNumber++){
// testa se o próximo movimento é válido
if(((currentRow + vertical[moveNumber] >= 0)&&(currentRow + vertical[moveNumber] <= 7)) && ((currentColumn + horizontal[moveNumber] >= 0)&&(currentColumn + horizontal[moveNumber] <= 7))){
if(board[currentRow + vertical[moveNumber]][currentColumn + horizontal[moveNumber]] != true ){
// Caso seja válido adiciona o movimento ao array com outros para posterior escolha do melhor
movsValidos.add(moveNumber);
}
}
}
if(!movsValidos.isEmpty()){
moveParaMelhor(movsValidos);
movsValidos.clear();
}else
jogo = "Acabou";
}while(jogo != "Acabou");
System.out.printf("Cavalo andou %d posições e parou na posição do tabuleiro[%d][%d]%n", count, currentRow, currentColumn);
if(count == 64)
contagem++;
System.out.printf("Total de vitórias: %d%n", contagem);
count = 0;
jogo = "Válido";
zeraBoard();
}
}
}
public static void moveParaMelhor(ArrayList moves){
for(Integer move: moves){
if(acessibility[currentRow + vertical[move]][currentColumn + horizontal[move]] <= melhorScore){
melhorScore = acessibility[currentRow + vertical[move]][currentColumn + horizontal[move]];
melhorMovimento = move;
}
}
// faz o movimento
currentRow += vertical[melhorMovimento];
currentColumn += horizontal[melhorMovimento];
System.out.printf("Movimento %d feito. Cavalo na posição do tabuleiro[%d][%d]%n", melhorMovimento, currentRow, currentColumn);
melhorScore = 8;
atualizaAcessibilidade();
}
public static void atualizaAcessibilidade(){
for(int c = 0; c < vertical.length; c++){
if(((currentRow + vertical[c] >= 0)&&(currentRow + vertical[c] <= 7)) && ((currentColumn + horizontal[c] >= 0)&&(currentColumn + horizontal[c] <= 7))){
--acessibility[currentRow + vertical[c]][currentColumn + horizontal[c]];
}
}
}
public static void zeraBoard(){
for(int t = 0; t < 8; t++)
for(int s = 0; s < 8; s++)
board[t][s] = false;
acessibility[0][0] = 2; acessibility[0][1] = 3; acessibility[0][2] = 4; acessibility[0][3] = 4;
acessibility[0][4] = 4; acessibility[0][5] = 4; acessibility[0][6] = 3; acessibility[0][7] = 2;
acessibility[1][0] = 3; acessibility[1][1] = 4; acessibility[1][2] = 6; acessibility[1][3] = 6;
acessibility[1][4] = 6; acessibility[1][5] = 6; acessibility[1][6] = 4; acessibility[1][7] = 3;
acessibility[2][0] = 4; acessibility[2][1] = 6; acessibility[2][2] = 8; acessibility[2][3] = 8;
acessibility[2][4] = 8; acessibility[2][5] = 8; acessibility[2][6] = 6; acessibility[2][7] = 4;
acessibility[3][0] = 4; acessibility[3][1] = 6; acessibility[3][2] = 8; acessibility[3][3] = 8;
acessibility[3][4] = 8; acessibility[3][5] = 8; acessibility[3][6] = 6; acessibility[3][7] = 4;
acessibility[4][0] = 4; acessibility[4][1] = 6; acessibility[4][2] = 8; acessibility[4][3] = 8;
acessibility[4][4] = 8; acessibility[4][5] = 8; acessibility[4][6] = 6; acessibility[4][7] = 4;
acessibility[5][0] = 4; acessibility[5][1] = 6; acessibility[5][2] = 8; acessibility[5][3] = 8;
acessibility[5][4] = 8; acessibility[5][5] = 8; acessibility[5][6] = 6; acessibility[5][7] = 4;
acessibility[6][0] = 3; acessibility[6][1] = 4; acessibility[6][2] = 6; acessibility[6][3] = 6;
acessibility[6][4] = 6; acessibility[6][5] = 6; acessibility[6][6] = 4; acessibility[6][7] = 3;
acessibility[7][0] = 2; acessibility[7][1] = 3; acessibility[7][2] = 4; acessibility[7][3] = 4;
acessibility[7][4] = 4; acessibility[7][5] = 4; acessibility[7][6] = 3; acessibility[7][7] = 2;
}
}