Leetcode 51. N-Queens && 52. N-Queens II(Hard)

Problem:

51.The n-queens puzzle is the problem of placing n queens on an n×n chessboard such that no two queens attack each other.

Given an integer n, return all distinct solutions to the n-queens puzzle.

Each solution contains a distinct board configuration of the n-queens’ placement, where ‘Q’ and ‘.’ both indicate a queen and an empty space respectively.

52.Follow up for N-Queens problem.

Now, instead outputting board configurations, return the total number of distinct solutions.

Example:

There exist two distinct solutions to the 4-queens puzzle:

51.

[

[“.Q..”, // Solution 1

“…Q”,

“Q…”,

“..Q.”],

[“..Q.”, // Solution 2

“Q…”,

“…Q”,

“.Q..”]

]

52.

2

Algorithm:

这两道题目为经典的n皇后问题，51题为列出所有的可行解，52题为求可行解的总数。
关于n皇后问题的基本解法是DFS。即遍历棋盘所有的行i，对每一行枚举所有的列j，判断第i个皇后放在(i,j)位置时是否会和前面i-1行的i-1个皇后发生冲突，若不冲突，则继续向下进行DFS。
判断冲突的方法是：判断(i,j)所在的行、列和两条斜线（4个数组）上是否已经有别的皇后，若是，则发生冲突。否则，没有冲突，并把(i,j)所在的行、列和两条斜线标记为已经有皇后。
对于时间复杂度的粗略计算为：第一行枚举n种情况，第二行n-1种情况……因此总的时间复杂度为O(n),但是上大部分情况都可排除，因此时间复杂度会更小。

Code:

这里只提供51的代码，52可通过改变返回类型获得

#include<iostream>
#include<vector>
#include<string>
using namespace std;

const int max_board=30;
int total_num=0;
vector<vector<string> > ans;

class Queens
{
public:
Queens(int size);
bool is_solved()const{
return count==board_size;
}
void print() const{
//cout << "下面是解决" << board_size << "皇后问题的第"<<total_num<<"组解" << endl;
vector<string> tv;
string ts;
for(int i=0;i<count;++i){
for(int j=0;j<count;++j){
if(j==queen_in_row[i]) {
//cout<<"Q";
ts.append("Q");
}
else {
//cout<<".";
ts.append(".");
}
//                  if(j==queen_in_row[i]){
//                      if(i==count-1) cout<<j+1;
//                      else cout<<j+1<<" ";
//                  }
}
//cout<<endl;
tv.push_back(ts);
ts.clear();
}
//cout<<endl;
ans.push_back(tv);
}
bool unguarded(int col)const;
void insert(int col);
void remove(int col);
void solve_from(Queens &configuration);
int board_size;

private:
int count;
bool col_free[max_board];
bool upward_free[2*max_board-1];
bool downward_free[2*max_board-1];
int queen_in_row[max_board];
};

Queens::Queens(int size)
{
board_size=size;
count=0;
for(int i=0;i<board_size;++i) col_free[i]=true;
for(int i=0;i<(2*board_size-1);++i){
upward_free[i]=true;
downward_free[i]=true;
}
}

void Queens::insert(int col)
{
queen_in_row[count]=col;
col_free[col]=false;
upward_free[count+col]=false;
downward_free[count-col+board_size-1]=false;
count++;
}

void Queens::remove(int col)
{
count--;
col_free[col]=true;
upward_free[count+col]=true;
downward_free[count-col+board_size-1]=true;
}

bool Queens::unguarded(int col)const
{
return col_free[col]&&upward_free[count+col]&&downward_free[count-col+board_size-1];
}

void Queens::solve_from(Queens &configuration)
{
if(configuration.is_solved()){
total_num++;
configuration.print();
}
else
{
for(int col = 0;col < configuration.board_size;++col)
{
if(configuration.unguarded(col))
{
configuration.insert(col);   //在(count,col)处放置皇后
solve_from(configuration);   //递归，继续求解
configuration.remove(col);   //去掉先前在(count,col)处放置的皇后
}
}
}
}

class Solution {
public:
vector<vector<string>> solveNQueens(int n) {
Queens configuration(n);
configuration.solve_from(configuration);
vector<vector<string>> as = ans;
ans.clear();
return as;
}
};