java回溯递归（骑士）

Question

这就像N皇后问题。 给定的电路板尺寸（行、列） 和骑士人数（骑士）

在给定的棋盘上我可以容纳多少骑士

我将使用嵌套的int数组

1代表骑士占领了那个地方

99将代表自现有骑士攻击以来，没有骑士可以进入的地方

0代表骑士可以进入的空位

在运行调试之后，我发现knights（3,3,5）

[1，-1，-1][99，-1，-99]在这里，我被卡住了，我必须后退。[-99，-99，-99]

但在回溯中，查看棋盘[0][0]骑士的位置将如何攻击-->；委员会[2][1]

并且，棋盘[0][2]骑士将攻击-->；委员会[2][1]

因此，当我回溯并撤销棋盘[0][2]上的骑士时

它也撤销了-99，这是不应该的，因为有一个以上的骑士同时攻击该空间

如果您能给我一些建议，我将不胜感激

public class knightsPlacement {

    public static void knights(int row, int col, int knights) {
        if(row < 0 || col < 0 || knights < 0) {
            System.out.println("Enter new parameters");
            return;
        }

        int [][] board = new int[row][col];

        for(int i = 0; i < board.length; i++) {
            for(int y = 0; y < board[0].length; y++) {
                board[i][y] = 0;
            }
        }


                solveKnights(board, 0, 0, knights);


    }

    public static boolean solveKnights(int[][] board, int row, int col, int knights) {


        if(row < 0 || row >= board.length || col < 0 || col >= board[0].length) {
            return false;
        }
        if(board[row][col] == -1 || board[row][col] == -99) {
            return false;
        }


        board[row][col] = -1;
        knights = knights -1;


        if(knights == 0) {
            return true;
        }
        if((row-2) >= 0 && (col-1) >=0 ) {
            board[row-2][col-1] = -99;
        }
        if((row-1) >= 0 && (col-2) >= 0) {
            board[row-1][col-2] = -99;
        }
        if((row-2) >= 0 && (col+1) < board[0].length) {
            board[row-2][col+1] = -99;
        }
        if((row-1) >= 0 && (col +2) < board[0].length) {
            board[row-1][col+2] = -99;
        }
        if((row+2) < board.length && (col-1) >=0 ) {
            board[row+2][col-1] = -99;
        }
        if((row+1) < board.length && (col-2) >= 0) {
            board[row+1][col-2] = -99;
        }
        if((row+2) < board.length && (col+1) < board[0].length) {
            board[row+2][col+1] = -99;
        }
        if((row+1) < board.length && (col+2) < board[0].length) {
            board[row+1][col+2] = -99;
        }
        for(int i = 0; i < board.length; i++) {
            System.out.println(Arrays.toString(board[i]));
        }
        System.out.println();


    for(int rowCount = 0; rowCount < board.length; rowCount++) {
        for(int colCount = 0; colCount < board[0].length; colCount++) {
                            if(solveKnights(board, rowCount,colCount, knights))return true; 
                        }
                    }



            board[row][col] = 0;
            knights = knights +1;

            if((row-2) >= 0 && (col-1) >=0 ) {
                board[row-2][col-1] = 0;
            }
            if((row-1) >= 0 && (col-2) >= 0) {
                board[row-1][col-2] = 0;
            }
            if((row-2) >= 0 && (col+1) < board[0].length) {
                board[row-2][col+1] = 0;
            }
            if((row-1) >= 0 && (col +2) < board[0].length) {
                board[row-1][col+2] = 0;
            }
            if((row+2) < board.length && (col-1) >=0 ) {
                board[row+2][col-1] = 0;
            }
            if((row+1) < board.length && (col-2) >= 0) {
                board[row+1][col-2] = 0;
            }
            if((row+2) < board.length && (col+1) < board[0].length) {
                board[row+2][col+1] = 0;
            }
            if((row+1) < board.length && (col+2) < board[0].length) {
                board[row+1][col+2] = 0;
            }

            return false;

    }

}