八皇后问题(N皇后问题)

八皇后问题是一个经典的递归回溯问题。

描述

八皇后问题是在一个 8*8 的棋盘上放置皇后,要求其放置后满足同一行,同一列,同一对角线上没有重复的皇后出现。试问有多少种摆盘方式?

思路

我们的主要思路是通过一行一行的放置皇后,来使得每一行都有一个皇后。当然,这些皇后在放置时都必须要满足规定的要求才行。

因此就会出先如下情况:

  • 放置时不符合规则,继续检索同一行的下一列位置是否合理
  • 如果符合规则就将其放置,然后进行下一行的尝试(递归)
  • 如果有某一行没有可行的解,则退回上一行,消除上一行摆放的皇后,检索剩余的列,看是否有合理的位置,然后继续进行。(回溯)
  • 直到所有的行都被放置为止。

需要注意的是,我们在放置皇后时需要检测其防止和理性的判断条件为:

  1. 同一列的上方所有行中是否有皇后
  2. 左上方对角线上是否有皇后
  3. 右上方对角线上是否有皇后

算法实现

public class EightQueen {

    private static final int num = 8; // 可以拓展为N皇后问题
    private static int[][] item = new int[num][num];
    private static int methods = 0; // 总方法数

    public static void main(String[] args) {
        buildQueen(0);
        System.out.println(methods);
    }

    /**
     * 构建棋盘的第row行
     *
     * @param row
     */
    private static void buildQueen(int row) {
        if (row == num) {
            methods++;
//            System.out.println("第" + methods + "种解法:");
//            for (int i = 0; i < num; i++) {
//                for (int j = 0; j < num; j++) {
//                    System.out.print(item[i][j] + " ");
//                }
//                System.out.print("\n");
//            }
            return;
        } else {
            for (int col = 0; col < num; col++) { // 每一列进行检查,试探性放置
                if (isSatisfy(row, col)) {
                    item[row][col] = 1;
                    buildQueen(row + 1);
                    item[row][col] = 0;
                }
            }
        }
    }

    /**
     * 检查row行col列元素是否满足要求
     * 因为是一行行的放置皇后,所以不需要检测同一行是否存在重复皇后
     * 在判断重复元素时,只需要判断上半部分的区域即可
     *
     * @param row
     * @param col
     * @return
     */
    private static boolean isSatisfy(int row, int col) {
        for (int i = 0; i < row; i++) {
            if (item[i][col] == 1) { // 同一列的上方元素
                return false;
            }
        }
        for (int i = row, j = col; i >= 0 && j >= 0; i--, j--) { // 左上方斜对角线
            if (item[i][j] == 1) {
                return false;
            }
        }
        for (int i = row, j = col; i >= 0 && j < num; i--, j++) { // 右上方斜对角线
            if (item[i][j] == 1) {
                return false;
            }
        }
        return true;
    }
}

优雅的位运算解法

我们直接从一个例子来讲解思路吧。先看看下图的情况:

《八皇后问题(N皇后问题)》 img1.jpeg

我们可以看到,前三行已经放置了皇后,我们需要在第四行选择放置皇后的点。阴影部分表示会出现冲突的格子,而冲突我们主要分为三种:同列冲突、右下方冲突和左下方冲突。

而就这对这种情况而言(此例为八皇后问题,可拓展到N皇后),一行刚好8个格子,对应8位二进制数字。因此我们可以首先定义冲突:

同列冲突: A = 1000 1001;

右下冲突: B = 0001 0010;

左下冲突: C = 0010 0010;

其中1表示冲突的格子,0表示可以放置皇后的格子。因此我们可以轻松得出综合的冲突情况:

D = (A | B | C) = 1011 1011;

对于我们将要放置的第四行而言,现在有两个0,意味着有两个可以放置皇后的位置,我们需要将所有的情况都考虑到,这里有一个神奇的式子:bit = (D + 1) & ~D; 它计算得出的结果是: 0000 0100;

其实它能够得到最右边一个可以放置皇后的位置,并用1来表示,其余位是0。 这样做是有好处的…

我们现在得出 bit = 0000 0100,便能够轻松得到下一行的冲突 A’ = (A | bit); B’ = (B | bit) >> 1; C’ = (C | bit) << 1; 便能够很轻易地写出递归式了。

而我们的第4行试探其实并没有结束,只是从左向右的第一个可以放置的位置进行了试探,那想要取到第二个可以放置的位置怎么办呢?很简单,只需要做如下运算:

D = D + bit 将刚才试过的那一位设置为不能放置皇后状态,然后继续做 bit = (D + 1) & ~D 即可。

一直循环的试探,知道D 全部为1 为止。

下面是整个程序的代码:

public class NQueen {

    private static final int N = 8; // 皇后数量,可拓展为N皇后
    private static int count = 0; // 总方法数
    private static int limit;

    public static void main(String[] args) {
        limit = (1 << N) - 1;
        backtracking(0, 0, 0, 0);
        System.out.println(count);
    }

    private static void backtracking(int a, int b, int c, int depth) {
        if (depth == N) {
            count++;
            return;
        }
        int d = a | b | c;
        while (d < limit) {
            int bit = (d + 1) & ~d;
            backtracking(a | bit, limit & ((b | bit) >> 1), limit & ((c | bit) << 1), depth + 1);
            d |= bit;
        }
    }
}

    原文作者:JYGod丶
    原文地址: https://www.jianshu.com/p/d16707207de8
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞

发表评论

电子邮件地址不会被公开。 必填项已用*标注