《程序员面试金典（第6版）》 面试题 08.12. 八皇后 （回溯法，棋盘问题，超级超级详细的代码解释！手把手教你如何分析解决问题，C++代码）

题目描述

设计一种算法，打印 N 皇后在 N × N 棋盘上的各种摆法，其中每个皇后都不同行、不同列，也不在对角线上。这里的“对角线”指的是所有的对角线，不只是平分整个棋盘的那两条对角线。

注意：本题相对原题做了扩展

示例:

 输入：4
 输出：[[".Q..","...Q","Q...","..Q."],["..Q.","Q...","...Q",".Q.."]]
 解释: 4 皇后问题存在如下两个不同的解法。
[
 [".Q..",  // 解法 1
  "...Q",
  "Q...",
  "..Q."],

 ["..Q.",  // 解法 2
  "Q...",
  "...Q",
  ".Q.."]
]

解题思路与代码

首先这道题是hard的难度的题。大家做好准备就好。

其次我看到这道题的第一感觉就是，这道题可以用回溯法去解决。那么接下来，就让我来带领大家，看看这道题到底是如何用回溯法解决的。

方法一： 回溯法 + 数学分析

这道题的难点是在于如何判断其中所在的两条对角线上有没有棋子。光是横数其实很好判断的。只需要用一个数组做标记就ok了。

那到底如何判断两条斜着的对角线呢？其实吧，说难也难，难在数学分析。说简单也简单，因为只需要和横竖上有没有多余的皇后一样，多了两条对角线，那就再多两个标记数组不就好了吗？

下面是教大家如何在遇到这种问题时，去做简单的数学分析：

• 这种方法基于观察和数学原理。在解决类似的问题时，观察数据和寻找规律是至关重要的。这种方法的发现过程如下：

• 观察：当尝试解决 N 皇后问题时，我们需要确保任何两个皇后不在同一行、同一列或同一对角线上。我们已经通过迭代来处理行和列的冲突，现在需要找到一种方法来处理对角线冲突。

• 发现规律：首先，我们可以观察到，对于正对角线，同一对角线上的格子的行索引和列索引之和是相等的（从左下往右上画对角线）。这是一个重要的规律，它可以帮助我们找到一个简单的方法来表示对角线。

• 数学表示：有了观察到的规律，我们可以用一个简单的数学表达式表示正对角线：d1 = row + col。同样，我们观察到反对角线上的格子的行索引和列索引之差是相等的。（从左上往右下画对角线）因此，我们可以得到表示反对角线的另一个数学表达式：d2 = row - col。在代码中，为了避免负索引，我们对反对角线的表达式进行了调整：d2 = n - 1 - row + col。

• 应用：通过这些数学表示，我们可以方便地检查皇后是否处于同一对角线上。我们用布尔数组来存储对角线上是否已经有皇后。这种方法降低了计算复杂度，使得算法更高效。

这个方法的发现过程就是一个典型的观察-发现规律-建立数学表示-应用的过程。在解决类似的算法问题时，这种思考方式非常有用。

如果大家可能对画对角线还是有点疑惑地话，我们来尝试用图形的方式解释正对角线和反对角线。以下是一个 5×5 的棋盘，其中数字表示正对角线和反对角线的索引：

正对角线索引:
00 01 02 03 04
01 02 03 04 05
02 03 04 05 06
03 04 05 06 07
04 05 06 07 08

反对角线索引（以负数表示，为了方便展示）:
-8 -7 -6 -5 -4
-7 -6 -5 -4 -3
-6 -5 -4 -3 -2
-5 -4 -3 -2 -1
-4 -3 -2 -1  0

在实际代码中，我们将反对角线索引加上 n - 1，这样可以将它们转换为非负整数。 以此为例，我们可以得到以下反对角线索引：

反对角线索引（非负整数表示）:
00 01 02 03 04
01 02 03 04 05
02 03 04 05 06
03 04 05 06 07
04 05 06 07 08

正如你在示例中所看到的，正对角线索引是根据 row + col 计算的，而反对角线索引是根据 n - 1 - row + col 计算的。这种表示方法使得我们能够很容易地检查在同一对角线上是否已经有皇后。

再解释清楚一点，那就是我上面讲的这个n，它是题目的传入参数的n乘过2再-1后的结果。 这里这么做的目的就是为了配合使用下标运算符不让负索引的情况出现。

讲了这么多，我感觉你多少得会一点了，具体的实现，请看下面代码：

class Solution {
public:
    // 主函数，输入皇后数量n，返回所有满足条件的摆放方法
    vector<vector<string>> solveNQueens(int n) {
        vector<vector<string>> result; // 保存所有解决方案的结果集
        vector<string> chessboard(n, string(n, '.')); // 初始化棋盘，用字符串表示每一行，初始状态为空
        vector<bool> cols(n, false); // 表示列上是否已经有皇后，初始状态为false
        vector<bool> diag1(2 * n - 1, false); // 表示正对角线上是否已经有皇后，初始状态为false 
        vector<bool> diag2(2 * n - 1, false); // 表示反对角线上是否已经有皇后，初始状态为false 
        backtrack(result, chessboard, 0, n, cols, diag1, diag2); // 调用回溯函数
        return result; // 返回结果集
    }
    // 回溯函数，用于递归地探索皇后的摆放方法
    // 参数分别为：结果集，当前棋盘状态，当前行数，总皇后数，列标记，正对角线标记，反对角线标记
    void backtrack(vector<vector<string>>& result, vector<string>& chessboard, int row, int n,
                   vector<bool>& cols, vector<bool>& diag1, vector<bool>& diag2) {
        if (row == n) { // 如果当前行数等于总行数，说明所有皇后已经摆放完成
            result.push_back(chessboard); // 将当前棋盘状态添加到结果集
            return;
        }
        // 遍历当前行的所有列，尝试将皇后放置在每一列上
        for (int col = 0; col < n; ++col) {
            //把点阵图画出来，你就明白是咋回事了。
            //正对角线（左下到右上）每一个坐标的横坐标 + 纵坐标的值是相等的。
            //反对角线（左上到右下）每一个坐标的横坐标 与 纵坐标的差值是相当的。
            //由此就可以推出对角线的定义公式，d1，d2
            int d1 = row + col; // 计算当前位置对应的正对角线索引，因为递归row会自动 + 1，正对角线是指从左下角到右上角的对角线
            int d2 = n - 1 - row + col; // 计算当前位置对应的反对角线索引，反对角线是指从左上角到右下角的对角线。

            // 判断当前位置是否可以放置皇后，如果在同一列、正对角线或反对角线上已经有皇后，则跳过
            if (cols[col] || diag1[d1] || diag2[d2]) {
                continue;
            }

            // 尝试在当前位置放置皇后
            chessboard[row][col] = 'Q';
            // 更新列、正对角线和反对角线的状态，将对应位置设为 true
            cols[col] = diag1[d1] = diag2[d2] = true;

            // 递归地在下一行尝试放置皇后
            backtrack(result, chessboard, row + 1, n, cols, diag1, diag2);

            // 回溯：撤销在当前位置放置的皇后
            chessboard[row][col] = '.';

            // 更新列、正对角线和反对角线的状态，将对应位置设为 false
            cols[col] = diag1[d1] = diag2[d2] = false;
        }
    }
};

复杂度分析

时间复杂度：

• 这个问题的解决方案使用了回溯算法。在最坏的情况下，算法会尝试所有可能的摆放方式。由于棋盘有 n 行，每一行有 n 个位置可以放置皇后，因此时间复杂度为 O(n!)。这是因为第一行有 n 个选择，第二行最多有 n-1 个选择，依此类推。这将产生一个类似于 n! 的时间复杂度。

空间复杂度：

• 结果集：由于解决方案数量不超过 N! 个（实际数量通常远小于 N!），每个解决方案需要 O(n) 空间来存储字符串。因此结果集的空间复杂度为 O(N! * n)。
  当前棋盘：空间复杂度为 O(n)。虽然棋盘是二维的，但我们每次只处理一行，每次回溯时，我们只修改当前行的内容。因此，棋盘空间复杂度实际上是 O(n) 而不是 O(n^2)。
  用于检查冲突的数据结构：cols、d1 和 d2 的空间复杂度为 O(n)。
  递归栈：在递归调用时，会使用递归栈。最大深度为 n。每一层递归调用的空间复杂度为 O(1)，因此递归栈空间复杂度为 O(n)。
  将所有部分相加，总空间复杂度为 O(N! * n + n + n + n) = O(N! * n + 3n)。在实际应用中，N 皇后问题通常解决的 N 值较小，因此算法的空间复杂度对于这类问题是可以接受的。

总结

这道题我觉得我最大的收获在于，去分析对角线那里的代码是如何去写的。学会了去做一些简单的数学分析去查找规律。很不错。