骑士'；java中的s教程（递归）

我正在为一个经典的骑士之旅编写代码，我的代码似乎大部分都在做正确的事情，但它仍然给我“不可能”的可能董事会，我不知道为什么。（例如：从第1行第3列开始，有3行4列的表失败）。我在计算行和列时从索引0开始。我不认为这是正确的回溯。有人能帮我指出我的错误吗？多谢各位

import java.util.*;
public class KnightGame 
{
    private int rows;
    private int cols;
    private int [][] array;

    public void initializeArray()
    {
        array = new int [rows][cols];
    }

    public boolean fill (int x, int y, int n)
    {
        if ( x < 0 || x >= rows || y<0 || y >= cols )  //outside of board
            return false;
        else if (array[x][y] != 0)   //location has been visited, array element occupied
            return false;
        else if ( n == (rows * cols))       //have visited all locations
            return true;
        else 
        {   
            array[x][y] = n;
            if ( fill(x+1, y-2, n+1) || fill(x-2, y+1, n+1) || fill(x+1, y+2, n+1)
               || fill(x+2, y+1, n+1) || fill(x-2, y-1, n+1) || fill(x-1, y-2, n+1) || 
               fill(x-1, y+2, n+1) || fill(x+2, y-1, n+1)) 
                return true;
            else
                return false;               
        }
    }

    public static void main (String [] args)
    {   
         KnightGame game = new KnightGame();
        int [] st = new int [2];
        int startx, starty;
        Scanner keyIn = new Scanner (System.in); 

        System.out.println("Enter number of rows: ");
        game.rows=keyIn.nextInt();

        System.out.println("Enter number of columns: ");
         game.cols = keyIn.nextInt();

        game.initializeArray();

        System.out.println("Enter starting location: ");
         for (int i=0; i<2; i++)
         {
             st[i] = keyIn.nextInt();
         }

         startx = st[0];
         starty = st[1];

         //testing for correct starting values
         System.out.println("starting values: " + startx + " " + starty);       

        if (game.fill(startx, starty, 1))
        {
            for (int i=0; i<game.rows; i++)
                {
                  for (int j=0; j<game.cols; j++)
                  {
                     System.out.print(game.array[i][j] + " "); 
                  } 
                }
        }

        else
            System.out.println("Board could not be completed!");

    }

}

import java.util.*；
公营骑士游戏
{
私有int行；
私人公司；
私有int[][]数组；
公共无效初始值设定项array（）
{
数组=新整数[行][cols]；
}
公共布尔填充（整数x，整数y，整数n）
{
如果（x<0 | | x>=行| | y=cols）//板外
返回false；
否则，如果（数组[x][y]！=0）//位置已被访问，则数组元素已被占用
返回false；
else if（n==（rows*cols））//已访问所有位置
返回true；
其他的
{   
数组[x][y]=n；
如果（填充（x+1，y-2，n+1）|填充（x-2，y+1，n+1）|填充（x+1，y+2，n+1）
||填充（x+2，y+1，n+1）|填充（x-2，y-1，n+1）|填充（x-1，y-2，n+1）|
填充（x-1，y+2，n+1）|填充（x+2，y-1，n+1））
返回true；
其他的
返回false；
}
}
公共静态void main（字符串[]args）
{   
KnightGame=新KnightGame（）；
int[]st=新的int[2]；
int startx，starty；
扫描仪输入=新扫描仪（系统输入）；
System.out.println（“输入行数：”）；
game.rows=keyIn.nextInt（）；
System.out.println（“输入列数：”）；
game.cols=keyIn.nextInt（）；
game.initializeArray（）；
System.out.println（“输入起始位置：”）；
对于（int i=0；i你回溯时没有清除板上的方块。因此，如果你沿着一条潜在路径递归，失败，然后尝试另一条路径，方块仍然从第一次尝试开始标记，因此第二次尝试也失败，即使可能

        array[x][y] = n;
        if ( fill(x+1, y-2, n+1) || fill(x-2, y+1, n+1) || fill(x+1, y+2, n+1)
           || fill(x+2, y+1, n+1) || fill(x-2, y-1, n+1) || fill(x-1, y-2, n+1) || 
           fill(x-1, y+2, n+1) || fill(x+2, y-1, n+1)) 
            return true;
        else
        {
            array[x][y] = 0; // <- add this line
            return false; 
        }

数组[x][y]=n；
如果（填充（x+1，y-2，n+1）|填充（x-2，y+1，n+1）|填充（x+1，y+2，n+1）
||填充（x+2，y+1，n+1）|填充（x-2，y-1，n+1）|填充（x-1，y-2，n+1）|
填充（x-1，y+2，n+1）|填充（x+2，y-1，n+1））
返回true；
其他的
{
数组[x][y]=0；//回溯时，您没有清除板上的方块。因此，如果您沿着一条潜在路径递归，失败，然后尝试另一条路径，方块仍然会从第一次尝试开始标记，因此第二次尝试也会失败，即使可能

        array[x][y] = n;
        if ( fill(x+1, y-2, n+1) || fill(x-2, y+1, n+1) || fill(x+1, y+2, n+1)
           || fill(x+2, y+1, n+1) || fill(x-2, y-1, n+1) || fill(x-1, y-2, n+1) || 
           fill(x-1, y+2, n+1) || fill(x+2, y-1, n+1)) 
            return true;
        else
        {
            array[x][y] = 0; // <- add this line
            return false; 
        }

数组[x][y]=n；
如果（填充（x+1，y-2，n+1）|填充（x-2，y+1，n+1）|填充（x+1，y+2，n+1）
||填充（x+2，y+1，n+1）|填充（x-2，y-1，n+1）|填充（x-1，y-2，n+1）|
填充（x-1，y+2，n+1）|填充（x+2，y-1，n+1））
返回true；
其他的
{
数组[x][y]=0；//问题在于，当回溯发生时，您的代码没有将位置重置为0，下一次在另一个过程中，它会感到困惑，以为它在那里，但该点应该已重置。下面是一个修复代码片段：

else 
{   
    array[x][y] = n;
    if ( fill(x+1, y-2, n+1) || fill(x-2, y+1, n+1) || fill(x+1, y+2, n+1)
       || fill(x+2, y+1, n+1) || fill(x-2, y-1, n+1) || fill(x-1, y-2, n+1) || 
       fill(x-1, y+2, n+1) || fill(x+2, y-1, n+1)) 
        return true;
    else {
        array[x][y] = 0;//NEED THIS LINE
        return false; 
    }              
}

问题是，当回溯发生时，您的代码没有将位置重置为0，下一次在另一个过程中，它会感到困惑，以为它在那里，但该点应该已重置。以下是修复程序的代码片段：

else 
{   
    array[x][y] = n;
    if ( fill(x+1, y-2, n+1) || fill(x-2, y+1, n+1) || fill(x+1, y+2, n+1)
       || fill(x+2, y+1, n+1) || fill(x-2, y-1, n+1) || fill(x-1, y-2, n+1) || 
       fill(x-1, y+2, n+1) || fill(x+2, y-1, n+1)) 
        return true;
    else {
        array[x][y] = 0;//NEED THIS LINE
        return false; 
    }              
}

您还可以共享失败的用例吗？3行4列，从第1行开始，第3列使用索引0开始计算行和列扫描您还可以共享失败的用例吗？3行4列，从第1行开始，第3列使用索引0开始计算行和列