我试图实现一个骑士游问题的解决方案。我遇到了一个有趣的问题。我想知道行为的原因。
这是代码-它工作正常。

public class OpenKnightTour {

    private int[][] chessTable;
    private int startRow;
    private int startCol;
    private int ChessBoardSize;

    private final int[][] moves = {
            {-1, -2},
            {-2, -1},
            {-2, 1},
            {-1, 2},
            {1, -2},
            {2, -1},
            {2, 1},
            {1, 2}
    };

    public OpenKnightTour(int ChessBoardSize, int startRow, int startCol){
        this.ChessBoardSize = ChessBoardSize;
        this.startRow = startRow;
        this.startCol = startCol;
        this.chessTable = new int[ChessBoardSize][ChessBoardSize];
    }

    void move(){
        //first move
        this.chessTable[this.startRow][this.startCol] = 1;

        //start with 2nd move recursively
        moveHelper(this.startRow, this.startCol, 2);

        //print results
        this.print();

    }

    private boolean moveHelper(int r, int c, int count){
        if((count-1) == (this.ChessBoardSize * this.ChessBoardSize))
            return true;

        for(int[] move: moves){
            int nextR = r + move[0];
            int nextC = c + move[1];
            if(isMoveValid(nextR, nextC)){
                chessTable[nextR][nextC] = count;
                if(moveHelper(nextR, nextC, count + 1)){
                    return true;
                }
                chessTable[nextR][nextC] = 0;
            }
        }
        return false;
    }

    private void print(){
        Arrays.stream(this.chessTable)
                .forEach(a -> System.out.println(Arrays.toString(a)));
    }

    private boolean isMoveValid(int r, int c){
        if(!(r >= 0 && r < this.ChessBoardSize))
            return false;
        if(!(c >= 0 && c < this.ChessBoardSize))
            return false;
        return chessTable[r][c]==0;
    }

}

现在我们可以运行它，从矩阵中的马位置(2, 2)开始

OpenKnightTour o = new OpenKnightTour(8, 2, 2);
    o.move();

当我试着运行(0, 0)的起始位置时，它一直在运行，没有显示任何结果。所以我认为它不可能有任何解决方案。但是如果我稍微改变一下下面的顺序，它马上就工作得很好。

private final int[][] moves = {
        {-1, -2},
        {-2, -1},
        {-2, 1},
        {-1, 2},
        {1, -2},
        {1, 2}, //moved from last 
        {2, -1},
        {2, 1},
};

到底是怎么回事？，这个动作的位置怎么会对表现有这么大的影响？，那么在这种情况下，我们怎么知道正确的动作顺序呢？