void solveNQueens(const int n, vector<int> & steps, vector<vector<string> > & res)
{
if (steps.size() == n)
{
vector<string> v;
for (int i = 0; i < n; i++)
{
string tmp(n, '.');
tmp[steps[i]] = 'Q';
v.push_back(tmp);
}
res.push_back(v);
return;
}
else
{
int row = steps.size();
for (int i = 0; i < n; i++)
{
//每走一步，都要看下当前step是否vaild
if (vaild(row, i, steps))
{
//对当前row的每个col进行遍历
steps.push_back(i);
solveNQueens(n, steps, res);
steps.pop_back();
}
}
}
}
int totalNQueens(int n) {
vector<bool> cols(n, true);
vector<bool> left_right(2*n-1, true);
vector<bool> right_left(2*n-1, true);
int count = 0;
solveNQueens(0, cols, left_right, right_left, count);
return count;
}
vector<vector<string>> solveNQueens(int n) {
vector<vector<string>> res;
vector<string> cur(n, string(n, '.'));
col = new bool[n];
cross = new bool[n * 2 - 1];
anti_cross = new bool[n * 2 - 1];
solveNQueens(0, n, &cur, &res);
delete[] col, cross, anti_cross;
return res;
}
int main()
{
int* board= (int*) malloc(64*4);
solveNQueens(8);
// initBoard(board,8);
// printBoard(board,8);
// solveNQueens(board);
return 0;
}
vector<vector<string> > solveNQueens(int n) {
vector<vector<string> > res;
vector<string> nQueens(n, string(n, '.'));
vector<bool> flag_col(n, false); // indicate if the column had a queen before
vector<bool> flag_45(2 * n - 1, false); // indicate if the 45° diagonal had a queen before.
vector<bool> flag_135(2 * n - 1, false); // indicate if the 135° diagonal had a queen before.
solveNQueens(res, nQueens, flag_col, flag_45, flag_135, 0, n);
return res;
}
vector<vector<string> > solveNQueens(int n) {
// write your code here
vector<vector<string> > res;
if(n==2 || n == 3 || n <= 0) {
return res;
}
string s(n, '.'); // construction
vector<string> board(n, s);
solveNQueens(res, board, 0, n);
return res;
}
/*
Refer to:
https://discuss.leetcode.com/topic/13617/accepted-4ms-c-solution-use-backtracking-and-bitmask-easy-understand
The number of columns is n, the number of 45° diagonals is 2 * n - 1,
the number of 135° diagonals is also 2 * n - 1.
When reach [row, col], the column No. is col,
the 45° diagonal No. is row + col and the 135° diagonal No. is n - 1 + col - row.
| | | / / / \ \ \
O O O O O O O O O
| | | / / / / \ \ \ \
O O O O O O O O O
| | | / / / / \ \ \ \
O O O O O O O O O
| | | / / / \ \ \
3 columns 5 45° diagonals 5 135° diagonals (when n is 3)
*/
void solveNQueens(int row, vector<bool> &cols, vector<bool> &lr, vector<bool> &rl, int &count){
if(row==cols.size()){
count ++;
return;
}
for(int i=0; i<cols.size(); i++){
if(cols[i] && lr[row+cols.size()-1-i] && rl[row+i]){
cols[i] = lr[row+cols.size()-1-i] = rl[row+i] = false;
solveNQueens(row+1, cols, lr, rl, count);
cols[i] = lr[row+cols.size()-1-i] = rl[row+i] = true;
}
}
}
void solveNQueens(vector<vector<string>>& res, vector<string>& s, int& n, int row) {
if(row == n) {
res.push_back(s);
return;
}
for(int column = 0; column < n; column++) {
if(isValidPos(s, n, row, column)) {
s[row][column] = 'Q';
solveNQueens(res, s, n, row + 1);
s[row][column] = '.'; // reset to find another solutions
}
}
}
void NQueens::solveNQueens(size_t n, size_t row, const unique_ptr<vector<int>> &colPlacement,
std::vector<std::vector<int>> &result) {
if (row == n) {
result.push_back(*colPlacement);
return;
}
for (int col = 0; col != (int)n; ++col) {
colPlacement->push_back(col);
if (isValid(*colPlacement))
solveNQueens(n, row + 1, colPlacement, result);
colPlacement->pop_back();
}
}
void solveNQueens(vector<vector<string> > &res, vector<string> &board, int index, int n) {
if(index == n) {
res.push_back(board);
return;
}
for(int i=0; i<n; i++) {
if(isClear(board, i, index, n)) {
board[i][index] = 'Q';
solveNQueens(res, board, index+1, n);
board[i][index] = '.';
}
}
}
void solveNQueens(int cur_line, int n, vector<string>* cur,
vector<vector<string>>* res) {
if (cur_line == n) {
res->push_back(*cur);
return;
}
for (int i = 0; i < n; i++) {
const int cross_num = i - cur_line + n - 1;
const int anti_num = i + cur_line;
if (col[i] == 0 && cross[cross_num] == 0 && anti_cross[anti_num] == 0) {
col[i] = cross[cross_num] = anti_cross[anti_num] = 1;
(*cur)[cur_line][i] = 'Q';
solveNQueens(cur_line + 1, n, cur, res);
(*cur)[cur_line][i] = '.';
col[i] = cross[cross_num] = anti_cross[anti_num] = 0;
}
}
}
void solveNQueens(vector<vector<string> > &res, vector<string> &nQueens, vector<bool> &flag_col, vector<bool> &flag_45, vector<bool> &flag_135, int row, int n) {
if (row == n) {
res.push_back(nQueens);
return;
}
for (int col = 0; col < n; col++)
if (flag_col[col] == false && flag_45[row+col] == false && flag_135[n-1+col-row] == false) {
flag_col[col] = flag_45[row + col] = flag_135[n - 1 + col - row] = true;
nQueens[row][col] = 'Q';
solveNQueens(res, nQueens, flag_col, flag_45, flag_135, row+1, n);
nQueens[row][col] = '.';
flag_col[col] = flag_45[row + col] = flag_135[n - 1 + col - row] = false;
}
}
vector<vector<int>> NQueens::nQueens(size_t n) {
vector<vector<int>> res;
unique_ptr<vector<int>> ptr(new vector<int>);
solveNQueens(n, 0, ptr, res);
return res;
}
vector<vector<string>> solveNQueens(int n) {
vector<vector<string>> res;
vector<string> s(n, string(n, '.'));
solveNQueens(res, s, n, 0);
return res;
}
vector<vector<string> > solveNQueens(int n) {
vector<vector<string> > res;
vector<int> steps;
solveNQueens(n, steps, res);
return res;
}
