回溯算法--8皇后问题

前些天有同学去跑社招，面试的时候被人问到8皇后问题，很是杯具。这也说明我们平时对于经典的算法问题关注太少，但设计算法的能力也不是一日之功，需要的是长期的练习和锻炼提高，比如我就很需要锻炼啊，哈哈。

废话不多说，来分析一下问题。

8皇后问题是要在8*8的国际象棋棋盘上放8个皇后，使得任意两个皇后都不能互相吃掉。因为皇后可以吃掉同一行、同一列和同一对角线上的任意棋子，类似于中国象棋的车。求出所有问题解。

这里可以设8个皇后，她们分别在不同的行i（i=1,2,3,4,...,8），而不同的皇后x要在的列，因此解可以有8个点所组成的二维数组。

回溯算法简单来说，就是走不通就掉头再走。这里就简单的使用八重循环进行深度优先搜索，从第一个皇后开始，再找第二个；每找一个就检查是否满足不能被吃掉的约束条件，不满足就continue回溯到上一个皇后，然后继续再尝试下一个。

不被吃掉的条件有三个：

1）不在同一列：x_i != x_j

2)不在同一对角线：x_i - i !=x_j - j && x_i + i !=x_j + j

EightQueens类：

package com.mnid.algorithm;
public class EightQueens {

    private int a[] = new int[9];
    
    public void place() {
        for (a[1] = 1; a[1] <= 8; a[1] += 1) {
            for (a[2] = 1; a[2] <= 8; a[2] += 1) {
                if (check(a, 2))
                    continue;
                for (a[3] = 1; a[3] <= 8; a[3] += 1) {
                    if (check(a, 3))
                        continue;
                    for (a[4] = 1; a[4] <= 8; a[4] += 1) {
                        if (check(a, 4))
                            continue;
                        for (a[5] = 1; a[5] <= 8; a[5] += 1) {
                            if (check(a, 5))
                                continue;
                            for (a[6] = 1; a[6] <= 8; a[6] += 1) {
                                if (check(a, 6))
                                    continue;
                                for (a[7] = 1; a[7] <= 8; a[7] += 1) {
                                    if (check(a, 7))
                                        continue;
                                    for (a[8] = 1; a[8] <= 8; a[8] += 1) {
                                        if (check(a, 8))
                                            continue;
                                        else {
                                            for (int i = 1; i <= 8; i++) {
                                                System.out.println("(" + i
                                                        + ", " + a[i] + ")");
                                                if (8 == i) {
                                                    System.out.println("-----------------");
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }

    private boolean check(int[] a, int n) {
        for (int i = 1; i <= n - 1; i++) {
            if (Math.abs(a[i] - a[n]) == Math.abs(i - n) || a[i] == a[n]) {
                return true;
            }
        }
        return false;
    }
}

这个算法缺陷就是只能解决8皇后问题。

 

对于n皇后问题，以下是采用非递归的深度优先搜索算法实现：

NQueens类：

package com.mnid.algorithm;

public class NQueens {
    private int a[] = new int[20];
    
    public void place(int n) {
         int k = 1;
         while (k > 0) {
             a[k] += 1;
             while (a[k] <= n && check(k)) {        //放第k个皇后
                 a[k] += 1;
             }
             if (a[k] <= n) {
                 if (k == n) {        //找到一组解
                     print(n);
                 }else {
                     k += 1;        //前k个皇后已放好,继续放第k+1个皇后
                     a[k] = 0;        //从头开始继续放下一个
                 }
             } else {
                 k -= 1;            //出界则回溯
             }
         }
    }
    
    private void print(int n) {
        for (int i=1; i<=n; i++) {
            System.out.println("(" + i
                    + ", " + a[i] + ")");
            if (n == i) {
                System.out.println("-----------------");
            }
        }
    }

    private boolean check(int n) {
        for (int i = 1; i <= n - 1; i++) {
            if (Math.abs(a[i] - a[n]) == Math.abs(i - n) || a[i] == a[n]) {
                return true;
            }
        }
        return false;
    }
}

Placer类：

package com.mnid.algorithm;

public class Placer {
    public static void main(String[] args) {
        new EightQueens().place();
//        new NQueens().place(8);
    }

}