LeetCode51N皇后

51. N 皇后

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

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

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

每一种解法包含一个明确的 n 皇后问题的棋子放置方案，该方案中 'Q' 和 '.' 分别代表了皇后和空位。

 

示例：

输入：4
输出：[
 [".Q..",  // 解法 1
  "...Q",
  "Q...",
  "..Q."],

 ["..Q.",  // 解法 2
  "Q...",
  "...Q",
  ".Q.."]
]
解释: 4 皇后问题存在两个不同的解法。

 

提示：

• 皇后彼此不能相互攻击，也就是说：任何两个皇后都不能处于同一条横行、纵行或斜线上。

class Solution:
    def solveNQueens(self, n: int) -> List[List[str]]:
        self.ans_perms = []
        self.n = n
        self.hashset = set()
        self.generateP(0, [])
        # ans -> Q..
        ans = []
        for item in self.ans_perms:
            cur_ans = []
            for i in item:
                cur_ans.append("."*i + "Q" + "."*(n-i-1))
            ans.append(cur_ans)
        return ans

    def generateP(self, idx, cur_perm):
        if idx == self.n and self.check(cur_perm):
            self.ans_perms.append(cur_perm[:])  # attention
            return
        for i in range(self.n):
            if i not in self.hashset:
                cur_perm.append(i)
                self.hashset.add(i)
                self.generateP(idx + 1, cur_perm)
                cur_perm.pop(-1)
                self.hashset.remove(i)
    

    def check(self, p):
        for i in range(self.n - 1):
            for j in range(i+1, self.n):
                if abs(i -j) == abs(p[i] - p[j]):
                    return False
        return True

---

const int MAXN = 50;
int ansCur[MAXN];//存储一个方案，列号
bool hashTable[MAXN] = {false};
class Solution {
private:
    int N;  //皇后个数
    vector<vector<string> > ans;

public:
    vector<vector<string>> solveNQueens(int n) {
        N = n;
        generateP(1);
        return ans;
    }

    //产生一个排列，并判断任意两个皇后是否存在对角线冲突
    void generateP(int idx){
        if(idx == N+1){
            bool flag = true;
            for(int i=1; i<=N; i++)
                for(int j=i+1; j<=N; j++)
                    if(abs(i-j) == abs(ansCur[i]-ansCur[j])){
                        flag = false;
                        break;
                    }
            
            if(true == flag)
                saveAns();
            return;
        }
        for(int j=1; j<=N; j++){
            if(hashTable[j] == false){
                ansCur[idx] = j;
                hashTable[j] = true;
                generateP(idx+1);
                hashTable[j] = false;
            }
        }  
    }

    void saveAns(){
        vector<string> tmp;
        for(int i=1; i<=N; i++){
            string s = "";
            for(int j=1; j<=N; j++){
                if(ansCur[i] == j)
                    s += "Q";
                else
                    s += "." ;
            }
            tmp.push_back(s);
            s.clear();
        }
        ans.push_back(tmp);
    }
};

CwithSTL形式

#include<iostream>
using namespace std;

int n;		//n的全排列
int cnt = 0;	//n皇后的方案数 
const int MAXN = 15;
bool hashTable[MAXN] = {false};	//从下标1开始使用 
int ans[MAXN];				//存放一个排列

void generateP(int idx){
	if(n+1 == idx){		//到达边界，生成全排列的一个
		//对全排列进行操作
		//判断该排列是否造成任意两个皇后冲突（此时冲突只可能是独角线）
		bool flag = true;
		for(int i=1; i<=n; i++)
			for(int j=i+1; j<=n; j++)
				if(abs(i-j) == abs(ans[i]-ans[j])){ 
					flag = false;
					break;
				}
		
		if(true == flag){
			cnt++;
		}	
		return;	 
	}
	//尝试对排列的第idx位进行分配 
	//可进行改进，分配之前判断是否会和已经分配的皇后形成冲突 
	for(int j=1; j<=n; j++){
		if(false == hashTable[j]){
			ans[idx] = j;
			hashTable[j] = true;
			generateP(idx+1);
			hashTable[j] = false;
		}
	}
}

int main(){
	cin>>n;
	generateP(1);
	
	cout<<cnt; 
	return 0;
}

效率较低，可以剪枝优化