难度：困难

题目：

    n 皇后问题研究的是如何将 n 个皇后放置在 n×n 的棋盘上，并且使皇后彼此之间不能相互攻击。

    上图为 8 皇后问题的一种解法。

    给定一个整数 n，返回 n 皇后不同的解决方案的数量。

提示：

    皇后，是国际象棋中的棋子，意味着国王的妻子。皇后只做一件事，那就是“吃子”。当她遇见可以吃的棋子时，就迅速冲上去吃掉棋子。

    当然，她横、竖、斜都可走一或 N-1 步，可进可退。(引用自 百度百科 - 皇后 )

--------------------------------------------

    N皇后问题，经典的题目，记得大学老师很喜欢用来做教学题材，回溯法的入门经典教学用例，8皇后。

    只不过这里不是8皇后，是N个皇后，其实做法都大同小异，只不过一个是写死8个皇后，一个是支持输入而已。

    N皇后问题应该有耳朵的都听过了吧。

    就是如果当前皇后所在位置，如果上下左右外加 斜上下左右的，已经有存在皇后的话，那就是冲突，就不能放，只能找其他位置。

5皇后例子

    如果能找到符合需求的n个皇后都完美放在了棋盘中的话，那就是一个完美的答案，现在需要把所有的答案打印出来，皇后的位置是“Q”，其他空位置为“.”表示。

    这是回溯法的专用教学案例，当然这里也是使用回溯法。

回溯法基本思想就是：

    回溯法(探索与回溯法)是一种选优搜索法，又称为试探法，按选优条件向前搜索，以达到目标。但当探索到某一步时，发现原先选择并不优或达不到目标，就退回一步重新选择，这种走不通就退回再走的技术为回溯法，而满足回溯条件的某个状态的点称为“回溯点”。

    其实回溯法在之前的《将数组拆分成斐波那契序列》中也有用到，但是那个还不够经典。

    归于当前需求，并结合回溯法思想，也就是找到每行的每一个皇后在哪一列来确定他的坐标[i, j]。

    这里我按列来说。

    从第一列的第一行开始，判断之前的列有没冲突，如果有就向下走一格，如果没有就放下。

    继续判断第二列的皇后。

    。    

。

    当到了第n列时，如果这列的皇后放在第x行刚好和之前的没有冲突，那就是一个答案，然后再向下找(当然已经没有了，因为每一次到最后一列只有一个答案)。

    那最后一列的已经找到了最后一行了呢，那就来了，回溯。

    退回到前一列(第n-1列)，然后前一列的皇后继续往下面的行移动，如果找到了再继续后一列(第n列)的判断。如果没有就再回溯，回到了n-2列，然后同理的操作。

    当退回到第1列时，全都试探完了，那就是完了。

    这里还可以优化了一下，把二维数组换成了单维数组，i-n和a[i]分别代表行和列。

递归实现：

public List> solveNQueens(int n) {    List> solutions = new ArrayList>();    int[] queens = new int[n];    Arrays.fill(queens, -1);    Set columns = new HashSet();    Set diagonals1 = new HashSet();    Set diagonals2 = new HashSet();    backtrack(solutions, queens, n, 0, columns, diagonals1, diagonals2);    return solutions;}public void backtrack(List> solutions, int[] queens, int n, int row, Set columns, Set diagonals1, Set diagonals2) {    if (row == n) {        List board = generateBoard(queens, n);        solutions.add(board);    } else {        for (int i = 0; i < n; i++) {            if (columns.contains(i)) {                continue;            }            int diagonal1 = row - i;            if (diagonals1.contains(diagonal1)) {                continue;            }            int diagonal2 = row + i;            if (diagonals2.contains(diagonal2)) {                continue;            }            queens[row] = i;            columns.add(i);            diagonals1.add(diagonal1);            diagonals2.add(diagonal2);            backtrack(solutions, queens, n, row + 1, columns, diagonals1, diagonals2);            queens[row] = -1;            columns.remove(i);            diagonals1.remove(diagonal1);            diagonals2.remove(diagonal2);        }    }}public ListgenerateBoard(int[] queens, int n) {    List board = new ArrayList();    for (int i = 0; i < n; i++) {        char[] row = new char[n];        Arrays.fill(row, '.');        row[queens[i]] = 'Q';        board.add(new String(row));    }    return board;}

    时间复杂度：O(n的n次方)

    空间复杂度：O(n+x)

非递归实现：

class Solution {    public List> solveNQueens(int n) {        List> lists = new ArrayList<>();        int i = 1;        // 用数组a存储棋子坐标，可以理解为i代表列，a[i]代表行        int[] a = new int[n+1];        while (i > 0) {            // i为当前列，寻找前面各列与当前第i列的排斥情况，拿到的a[i]就是当前行i的合适a[i]列            for (a[i]++; a[i]<=n; a[i]++) if (check2(a, i)) break;            // 如果a[i]列小于n，则可以继续向后找            if (a[i] <= n) {                // 如果当前行i就是第n行，则数量加1                if (i == n) {                    Listlist = new ArrayList<>();                    for (int i2 : a) {                        StringBuilder sb = new StringBuilder();                        for (int j = 0; j < n; j++) {                            if (j + 1 == i2) sb.append("Q");                            else sb.append(".");                        }                        list.add(sb.toString());                    }                    list.remove(0);                    lists.add(list);                    // 否则就是向后一列找，并且后面一列无论是有没找过都要重置为0；                } else {                    i++;                    a[i] = 0;                }                // 否则就是回溯，回到前一列(然后继续向下面行找)            } else {                i--;            }        }        return lists;    }    private static boolean check2(int[] a, int n) {        for (int i=1; i            if (Math.abs(a[i]-a[n])==Math.abs(i-n) || a[i]==a[n])                return false;        }        return true;    }}

    时间复杂度：O(n!)

    空间复杂度：O(n+x)

-----------------------------------未完-----------------------------------

    后面还有一个八皇后II，其实也就是大同小异，上面的是打印出棋盘，这个II就是计算个数(？？这特么有啥区别？)

    所以直接贴代码了。

递归实现：

public int totalNQueens(int n) {    Set columns = new HashSet();    Set diagonals1 = new HashSet();    Set diagonals2 = new HashSet();    return backtrack(n, 0, columns, diagonals1, diagonals2);}public int backtrack(int n, int row, Set columns, Set diagonals1, Set diagonals2) {    if (row == n) {        return 1;    } else {        int count = 0;        for (int i = 0; i < n; i++) {            if (columns.contains(i)) {                continue;            }            int diagonal1 = row - i;            if (diagonals1.contains(diagonal1)) {                continue;            }            int diagonal2 = row + i;            if (diagonals2.contains(diagonal2)) {                continue;            }            columns.add(i);            diagonals1.add(diagonal1);            diagonals2.add(diagonal2);            count += backtrack(n, row + 1, columns, diagonals1, diagonals2);            columns.remove(i);            diagonals1.remove(diagonal1);            diagonals2.remove(diagonal2);        }        return count;    }}

    时间复杂度：O(n的n次方)

    空间复杂度：O(n)

非递归实现：

public static int totalNQueens(int n) {    int count = 0, i = 1;    // 用数组a存储棋子坐标，可以理解为i代表列，a[i]代表行    int[] a = new int[n+1];    while (i > 0) {        // i为当前列，寻找前面各列与当前第i列的排斥情况，拿到的a[i]就是当前行i的合适a[i]列        for (a[i]++; a[i]<=n; a[i]++) if (check2(a, i)) break;        // 如果a[i]列小于n，则可以继续向后找        if (a[i] <= n) {            // 如果当前行i就是第n行，则数量加1            if (i == n) {                count++;            // 否则就是向后一列找，并且后面一列无论是有没找过都要重置为0；            } else {                i++;                a[i] = 0;            }        // 否则就是回溯，回到前一列(然后继续向下面行找)        } else {            i--;        }    }    return count;}private static boolean check2(int[] a, int n) {    for (int i=1; i        if (Math.abs(a[i]-a[n])==Math.abs(i-n) || a[i]==a[n])            return false;    }    return true;}

    时间复杂度：O(n!)

    空间复杂度：O(n)

    需要注意的是，递归的回溯法是一颗全部展开的树，时间复杂度是N的N次方，很灵恐怖，虽然好理解，但是还是建议用迭代法。

--------------------------------------------完--------------------------------------------

当我望向你的时候，多希望你也在看着我。