八皇后问题是一个古老而著名的问题，是回溯算法的典型例题。该问题是19世纪著名的数学家高斯1850年提出：在8×8格的国际象棋盘上摆放8个皇后，使其不能互相攻击，即任意两个皇后都不能处于同一行、同一列或同一斜线上，问有多少种摆法。[英国某著名计算机图形图像公司面试题]

算法1：典型的回朔算法。打印出8皇后的最终排列。
解析：递归实现n皇后问题。
算法分析：
数组a、b、c分别用来标记冲突，a数组代表列冲突，从a[0]~a[7]代表第0列到第7列。如果某列上已经有皇后，则为1，否则为0。
数组b代表主对角线冲突，为b[i-j+7]，即从b[0]~b[14]。如果某条主对角线上已经有皇后，则为1，否则为0。
数组c代表从对角线冲突，为c[i+j]，即从c[0]~c[14]。如果某条从对角线上已经有皇后，则为1，否则为0。

package org.luyang.csdn;

public class EightQueue {
    String[][] rec = new String[8][8];

    int[] a = new int[8];

    int[] b = new int[15];

    int[] c = new int[15];

    int sum;

    public EightQueue() {
        super();
        for (int i = 0; i < this.rec.length; i++) {
            for (int j = 0; j < this.rec[i].length; j++) {
                this.rec[i][j] = “○”;
            }
        }

    }

    public void prt() {
        System.out.println(“”);
        for (int i = 0; i < this.rec.length; i++) {
            for (int j = 0; j < this.rec[i].length; j++) {
                System.out.print(this.rec[i][j] + ” “);
            }
            System.out.println(“”);
        }

        System.out.println(“”);
    }

    /**
     * set the queen of line i
     *
     * @param i
     */
    void qu(int i) {
        for (int iColumn = 0; iColumn < 8; iColumn++) {
            if (a[iColumn] == 0 && b[i – iColumn + 7] == 0
                    && c[i + iColumn] == 0) {
                // do not conflict
                rec[i][iColumn] = “●”;
                a[iColumn] = 1;
                b[i – iColumn + 7] = 1;
                c[i + iColumn] = 1;
                if (i < 7)
                    qu(i + 1);
                else {
                    // sysout
                    prt();
                    sum++;
                }
                // whatever how to put the queen, mission is impossible. rollback
                rec[i][iColumn] = “○”;
                a[iColumn] = 0;
                b[i – iColumn + 7] = 0;
                c[i + iColumn] = 0;
            }
        }
    }

    /**
     * 8 queen
     * @param args
     */
    public static void main(String[] args) {
        EightQueue eq = new EightQueue();
        eq.qu(0);
        System.out.println(eq.sum);
    }
}

算法2，也不知道是从哪里剽窃过来的了，该算法没有最终答应出排列组合，仅仅给出有多少种组合，但是算法确实十分奥妙，提供出来大家分享。

package org.luyang.csdn;

public class Queen {
    static int sum = 0, upperlim = 1;

    private static void test(int row, int ld, int rd) {

        if (row != upperlim) {
            int pos = upperlim & ~(row | ld | rd);
            while (pos != 0) {
                int p = pos & -pos;
                pos -= p;
                test(row + p, (ld + p) << 1, (rd + p) >> 1);
            }
        } else
            sum++;
    }

    public static void main(String[] args) {
        int n = 8;

        if (args.length == 1)
            n = Integer.parseInt(args[0]);

        long tm = System.currentTimeMillis();
        if ((n < 1) || (n > 32)) {
            System.out.println(” heh..I can’t calculate that.”);
            System.exit(-1);
        }
        System.out.println(n + ” Queens”);
        upperlim = (upperlim << n) – 1;

        test(0, 0, 0);
        System.out.println(“Number of solutions is ” + sum + “, “
                + (System.currentTimeMillis() – tm) + ” milliseconds”);
    }
}