一、题目
按照国际象棋的规则，皇后可以攻击与之处在同一行或同一列或同一斜线上的棋子。
n 皇后问题 研究的是如何将 n 个皇后放置在 n×n 的棋盘上，并且使皇后彼此之间不能相互攻击。
给你一个整数 n ，返回所有不同的 n 皇后问题 的解决方案。
每一种解法包含一个不同的 n 皇后问题 的棋子放置方案，该方案中 ‘Q’ 和 ‘.’ 分别代表了皇后和空位。
来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/n-queens/description/
二、C++解法
我的思路及代码
采用回溯的思想。这里需要一个判断的函数 isValid ，来处理当前位置是否是可选的位置。每一次选择的时候都会前进一行，然后在当前行中，选择可用的列。如果这个列是可用的那么就可以选择此路径，然后继续后面的回溯，如果不可用则继续往下找。本质是一个全排列的问题。由于我们的方式是从一行一行的往下找，那么在 isValid 中，就不必判定左下角和右下角的合理情况，这必然是可选的。
class Solution {
public:
vector<vector<string>> ans;
bool isValid(int &row,int &col,vector<string> &temp){
int rowTemp = row;
int colTemp = col;
//判断列有没有棋子
for(int i=0;i<temp.size();i++){
if(temp[i][col] == 'Q')
return false;
}
//判断左上有没有棋子
for(;rowTemp>=0&&colTemp>=0;rowTemp--,colTemp--){
if(temp[rowTemp][colTemp] == 'Q')
return false;
}
//判断右上有没有棋子
for(rowTemp = row,colTemp = col;rowTemp>=0&&colTemp<temp.size();rowTemp--,colTemp++){
if(temp[rowTemp][colTemp] == 'Q')
return false;
}
return true;
}
void backtrance(vector<string> &temp,int row){
if(row==temp.size()){
ans.push_back(temp);
return;
}
for(int col=0;col<temp.size();col++){
if(isValid(row,col,temp)){
temp[row][col] = 'Q';
backtrance(temp,row+1);
temp[row][col] = '.';
}
}
}
vector<vector<string>> solveNQueens(int n) {
vector<string> temp(n,string(n,'.'));
backtrance(temp,0);
return ans;
}
};
- 时间复杂度：O(N!)，其中 N 是皇后数量
- 空间复杂度：O(N)，其中 N 是皇后数量。空间复杂度主要取决于递归调用层数、记录每行放置的皇后的列下标的数组以及三个集合，递归调用层数不会超过 N，数组的长度为 N，每个集合的元素个数都不会超过 N
官方参考代码
方法一：基于集合的回溯
采用了集合的方式来存储各个线上皇后的情况，本质还是回溯算法。
class Solution {
public:
vector<vector<string>> solveNQueens(int n) {
auto solutions = vector<vector<string>>();
auto queens = vector<int>(n, -1);
auto columns = unordered_set<int>();
auto diagonals1 = unordered_set<int>();
auto diagonals2 = unordered_set<int>();
backtrack(solutions, queens, n, 0, columns, diagonals1, diagonals2);
return solutions;
}
void backtrack(vector<vector<string>> &solutions, vector<int> &queens, int n, int row, unordered_set<int> &columns, unordered_set<int> &diagonals1, unordered_set<int> &diagonals2) {
if (row == n) {
vector<string> board = generateBoard(queens, n);
solutions.push_back(board);
} else {
for (int i = 0; i < n; i++) {
if (columns.find(i) != columns.end()) {
continue;
}
int diagonal1 = row - i;
if (diagonals1.find(diagonal1) != diagonals1.end()) {
continue;
}
int diagonal2 = row + i;
if (diagonals2.find(diagonal2) != diagonals2.end()) {
continue;
}
queens[row] = i;
columns.insert(i);
diagonals1.insert(diagonal1);
diagonals2.insert(diagonal2);
backtrack(solutions, queens, n, row + 1, columns, diagonals1, diagonals2);
queens[row] = -1;
columns.erase(i);
diagonals1.erase(diagonal1);
diagonals2.erase(diagonal2);
}
}
}
vector<string> generateBoard(vector<int> &queens, int n) {
auto board = vector<string>();
for (int i = 0; i < n; i++) {
string row = string(n, '.');
row[queens[i]] = 'Q';
board.push_back(row);
}
return board;
}
};
- 时间复杂度：O(N!)，其中 N 是皇后数量
- 空间复杂度：O(N)，其中 N 是皇后数量。空间复杂度主要取决于递归调用层数、记录每行放置的皇后的列下标的数组以及三个集合，递归调用层数不会超过 N，数组的长度为 N，每个集合的元素个数都不会超过 N
