Java （8个皇后）找出皇后是否适合2D矩阵

我正试图编写一个程序，用一个二维布尔数组来解决8皇后问题。我将使用回溯来找到解决方案。我知道这不是解决这个问题的最佳方法，为了简单起见，我可能应该选择一维数组，但我想用这种方法来解决它

现在我被一个函数卡住了，这个函数应该检查皇后是否适合给定的坐标。我的行、列和右下对角线检查有效，但左下对角线检查无效。我正在努力找到I和j（x和y）的正确索引开始，以及每个迭代的递增/递减计数器。现在，我的函数如下所示：

public static boolean fits(int x, int y) {

    for(int i = 0; i < N; i++) {
        if(board[x][i]) {
            return false; // Does not fit on the row
        }
    }

    for(int i = 0; i < N; i++) {
        if(board[i][y]) {
            return false; // Does not fit on the column
        }
    }

    for(int i = Math.max(x-y, 0), j = Math.max(y-x, 0); i < N && j < N; i++, j++) {
        if(board[i][j]) {
            return false; // Down right diagonal issue
        }
    }

    for(int i = Math.min(x+y, N-1), j = Math.max(N-1-x, 0); i >= 0 && j < N; i--, j++) {
        if(board[i][j]) {
            return false; // Supposed to check the down-left diagonal, but does not work.
        }
    }

    return true;
}

公共静态布尔拟合（int x，int y）{
对于（int i=0；i=0&&j

正如您所看到的，这里的最后一个循环存在问题。如果有人能给我一个working for循环来检查左下对角线，我会非常非常高兴。提前谢谢

---

编辑：以下是工作代码：

public class MyQueens {

    static boolean[][] board;
    static final int N = 8;

    public static void main(String[] args) {
        int p = 0;

        board = new boolean[N][N];

        board[1][1] = true;

        System.out.println(fits(0, 2));
        System.out.println(fits(2, 2));
    }

    public static boolean fits(int x, int y) {

        for(int i = 0; i < N; i++) {
            if(board[x][i]) {
                return false; // Row
            }
        }

        for(int i = 0; i < N; i++) {
            if(board[i][y]) {
                return false; // Column
            }
        }

        for(int i = 0, j = 0; i < N && j < 0; i++, j++) {
            if(board[i][j]) {
                return false; // for right diagonal
            }
        }

        int mirrorx = (N-1)-x;
        for(int i = Math.max(mirrorx-y, 0), j = Math.max(y-mirrorx, 0); i < N && j < N; i++, j++) {
            if(board[(N-1)-i][j]) {
                return false;
        }
    }

        return true;
    }

}

公共类MyQueens{
静态布尔[][]板；
静态最终整数N=8；
公共静态void main（字符串[]args）{
int p=0；
board=新布尔值[N][N]；
董事会[1][1]=正确；
系统输出println（fits（0,2））；
系统输出println（fits（2,2））；
}
公共静态布尔拟合（整数x，整数y）{
对于（int i=0；i

为什么不直接使用：

for(int i = 0, j = 0; i < N && j < 0; i++, j++) {
        if(board[i][j]) {
            return false; // for right diagonal
        }
    }

for（inti=0，j=0；i

同样地：

for(int i = 0, j = N-1; i < N && j >= 0; i++, j--) {
        if(board[i][j]) {
            return false; // for left diagonal
        }
    }

for（inti=0，j=N-1；i=0；i++，j--）{
如果（董事会[i][j]）{
返回false；//对于左对角线
}
}

只需水平翻转电路板，重复使用与右下对角线相同的算法：

int mirrorx = (N-1)-x;
for(int i = Math.max(mirrorx-y, 0), j = Math.max(y-mirrorx, 0); i < N && j < N; i++, j++) {
    if(board[(N-1)-i][j]) {
        return false;
    }
}

intmirrorx=（N-1）-x；
对于（inti=Math.max（mirrorx-y，0），j=Math.max（y-mirrorx，0）；i

你可以重新安排，使它更优化

我正试图编写一个程序，用一个二维布尔数组来解决8皇后问题

这不是最佳表示，因为必须使用四个循环来检查是否可以放置皇后。有一种更快的方法可以做到这一点

就您的计划而言，有四件事必须是没有威胁的，才能安置女王：

• 一排
• 一栏,
• 一条上升对角线，以及
• 下降对角线

这四件事中的每一件都可以用一个单独的布尔数组来建模。共有八行、八列、十五条上升对角线和十五条下降对角线（包括角落中一个单元格“对角线”的两种退化情况）

声明四个数组

行[8]

，

列[8]

，

asc[15]

和

desc[15]

，并使用这四种方法处理它：

public static boolean fits(int r, int c) {
    return !row[r] && !col[c] && !asc[r+c] && !desc[c-r+7];
}
public static void add(int r, int c) {
    set(r, c, true);
}
public static void remove(int r, int c) {
    set(r, c, false);
}
private static void set(int r, int c, boolean q) {
    row[r] = col[c] = asc[r+c] = desc[c-r+7] = q;
}

---

因为它不起作用。请看我的编辑——两个println都在main print true中，而它们应该打印false——这两个位置都不可能放置皇后。正如在OP中所述，我知道这在代码/操作的复杂性等方面既不是最优的，也不是好的。我已经有了一个1D数组的工作解决方案，但现在我正在尝试在2D中解决它。不过还是要感谢你的回答：）