N皇后详解

刷题刷到一道N皇后的题目，记录一下

N皇后是著名的八皇后推广，做起来还是挺有意思的

题目描述

在N*N的方格棋盘放置了N个皇后，使得它们不相互攻击（即任意2个皇后不允许处在同一排，同一列，也不允许处在与棋盘边框成45角的斜线上。
你的任务是，对于给定的N，求出有多少种合法的放置方法。

输入格式

测试数据由多组测试样例组成。每组测试数据第一行输入一个正整数 n ( 1 <= n <= 10 ）

输出格式

输出有多少种合法的放置方法

输入样例

1
5

输出样例

1
10

思路讲解

题目很容易理解，要实现也挺容易的。难点在优化上，题目要求1<=n<=10的N皇后情况全在1s内完成。咱先不求效率地实现一遍（不优化）。
下面分别给出不优化和优化的具体思路。

不优化

对于每一个皇后：
从(0, 0) 处遍历每一格（一行一行水平扫描）判断当前格能否放置皇后
1、能：放置，以放置后的棋盘去参加下一颗皇后的放置过程（从当前行开始）
2、不能：跳过，下一格
直到皇后放完，情况+1，开始回溯：移除最后放置的皇后，从移除皇后的下一格开始参与放置新皇后。
最后第一颗皇后从(0, 0) - (n - 1, n - 1)都放置了一遍（所有情况都已经遍历），求解结束，输出结果。
对于n=10的情况用时为7828ms。

优化

参考不优化进行改进，看这里时必须把不优化弄懂。
不难看出，对于每一颗皇后都从(0, y)开始遍历是极其低效的。根据皇后的攻击规则来说，一行内不能有多个皇后，所以在放置下一颗皇后时从上一颗皇后的下一行开始放置（对于下一个皇后从(0, y + 1)开始放置），即对已放置的最后一个皇后这一行及之前所有行进行剪枝。
对于n=10的情况用时为3060ms。
这就够了吗？当然不够，还有的多余情况是剩余行数比剩余皇后少，那么根据一行内不能有多个皇后的规则就能得出这是完全无法放完皇后的，也可以进行剪枝。
这样n=10的情况下能优化到27ms。

代码实现

分为递归和递推实现
但检查函数是一致的

bool check(vector<pair<int, int>>& q, int y, int x) {
    for (pair<int, int> pos : q) {
        int qy = pos.first, qx = pos.second;
        if (qy == y || qx == x) return false;
        int dx = abs(qx - x), dy = abs(qy - y);
        if (dx == dy) return false;
    }
 	return true;
}

传入的q记录了所有已摆放的皇后位置
只要满足以下两点的都算是该位置不符合摆放皇后的条件

1. 该位置的x或y和某何一个皇后的相应x或y相等（和该皇后处于同行或列）
2. |y - qy| == |x - qx|，即该位置和某一个皇后在对角线上

递归

结束条件：摆完n个皇后
中间的自我调用：从给定的sy开始遍历剩余所有行，对每一行遍历所有列，若该格满足摆放皇后的条件则放入皇后接着自我调用，自我调用结束后回溯（移除摆放的这个皇后）接着判断下一格。

long long dfs(vector<pair<int, int>>& q, int n, int sy = 0) {
	long long ans = 0;
	int c = q.size();
	
	//结束条件
	if (c == n) return 1;
	
	//从给定的sy开始遍历剩余所有行
	for (int y = sy; y < n; y++) {
		//剩余行数比剩余皇后少
		//if (n - y < n - c) => if (-y < -c) => if (y > c)
		if (y > c) break;
		//对每一行遍历所有列
		for (int x = 0; x < n; x++) {
			//判断是否满足摆放皇后的条件
			if (!check(q, y, x)) continue;
			//放入皇后
			q.push_back( {y, x} );
			//自我调用
			ans += dfs(q, n, y + 1);
			//回溯（移除摆放的这个皇后）
			q.erase(q.end() - 1);
		}
	} 
	
	return ans;
}

• q：存放已摆放皇后位置的容器
• n：需要摆放皇后的个数及棋盘大小（n*n）
• sy：默认为0，从sy开始遍历行
• 返回值：本层满足要求的摆法数

递推

一次外层循环有两个状态，由变量backdate控制
当backdate为false时：从y开始遍历每一行（一行对应一次外层循环执行过程），找到能摆放皇后的位置，直到超出棋盘大小或摆满N个皇后
当backdate为truew时：回溯，复位到上一个皇后位置的后一格并移除改皇后，关闭回溯（backdate = false）

long long recursive(vector<pair<int, int>>& q, int n) {
	long long ans;
	//判断位置
	int y, x;
	//是否回溯
	bool backdate;
	ans = 0;
	backdate = false;
	y = x = 0;
	for (int i = 0; i < n; y += (!backdate)) {
		//从0开始扫描
		x = 0;
		
		//当前行超出棋盘或满足优化二（剩余行数比剩余皇后少）
		//if (n - y < n - q.size()) => if (-y < -q.size()) => if (y > q.size())）
		//开始回溯 
		if (y == n || y > q.size()) backdate = true; 
		
		//回溯 
		if (backdate) {
			//取出最后一个摆法的皇后位置
			pair<int, int> pos = *(q.end() - 1);
			//恢复位置为pos（x+1是因为这个位置已经摆放过了，跳过）
			y = pos.first;
			x = pos.second + 1;
			//移除最后一个摆放的皇后
			q.erase(q.end() - 1);
			//关闭回溯
			backdate = false;
			//回溯到第一行，i++ 
			if (y == 0) i++; 
		}
		
		//寻找y行可放皇后的x 
		while (x < n && !check(q, y, x)) x++;
		//找到了则放置皇后 
		if (x != n) {
			//摆放皇后
			q.push_back({y, x});
			//放完了N个皇后，答案数 + 1， 开始回溯 
			if (q.size() == n) ans++, backdate = true;
		}
	}
	return ans; 
}

• q：存放已摆放皇后位置的容器
• n：需要摆放皇后的个数及棋盘大小（n*n）
• 返回值：满足要求的摆法数

不知道为啥，我的递推效率比递归慢一点，有大佬看出错误希望能为我指出，谢谢。

完全代码

#include <bits/stdc++.h>

using namespace std;

long long dfs(vector<pair<int, int>>& q, int n, int sy = 0) {
	long long ans = 0;
	int c = q.size();
	
	//结束条件
	if (c == n) return 1;
	
	//从给定的sy开始遍历剩余所有行
	for (int y = sy; y < n; y++) {
		//剩余行数比剩余皇后少
		//if (n - y < n - c) => if (-y < -c) => if (y > c)
		if (y > c) break;
		//对每一行遍历所有列
		for (int x = 0; x < n; x++) {
			//判断是否满足摆放皇后的条件
			if (!check(q, y, x)) continue;
			//放入皇后
			q.push_back( {y, x} );
			//自我调用
			ans += dfs(q, n, y + 1);
			//回溯（移除摆放的这个皇后）
			q.erase(q.end() - 1);
		}
	} 
	
	return ans;
}

long long recursive(vector<pair<int, int>>& q, int n) {
	long long ans;
	//判断位置
	int y, x;
	//是否回溯
	bool backdate;
	ans = 0;
	backdate = false;
	y = x = 0;
	for (int i = 0; i < n; y += (!backdate)) {
		//从0开始扫描
		x = 0;
		
		//当前行超出棋盘或满足优化二（剩余行数比剩余皇后少）
		//if (n - y < n - q.size()) => if (-y < -q.size()) => if (y > q.size())）
		//开始回溯 
		if (y == n || y > q.size()) backdate = true; 
		
		//回溯 
		if (backdate) {
			//取出最后一个摆法的皇后位置
			pair<int, int> pos = *(q.end() - 1);
			//恢复位置为pos（x+1是因为这个位置已经摆放过了，跳过）
			y = pos.first;
			x = pos.second + 1;
			//移除最后一个摆放的皇后
			q.erase(q.end() - 1);
			//关闭回溯
			backdate = false;
			//回溯到第一行，i++ 
			if (y == 0) i++; 
		}
		
		//寻找y行可放皇后的x 
		while (x < n && !check(q, y, x)) x++;
		//找到了则放置皇后 
		if (x != n) {
			//摆放皇后
			q.push_back({y, x});
			//放完了N个皇后，答案数 + 1， 开始回溯 
			if (q.size() == n) ans++, backdate = true;
		}
	}
	return ans; 
}

int main() {
	int n;
	map<int, long long> cache; 
	vector<pair<int, int>> q;
	
	while (cin >> n) {
		if (cache[n] != 0) {
			cout << cache[n] - 1 << endl;
			continue;
		}
		
		clock_t start = clock();
		long long ans1 = dfs(q, n);
		cout << "DFS: " << -(start - clock() * 1.0) / CLOCKS_PER_SEC << "s, ";
		start = clock();
		long long ans2 = recursive(q, n);
		cout << "Recursive: " << -(start - clock() * 1.0) / CLOCKS_PER_SEC << "s" << endl;
		
		if (ans1 != ans2) cout << "On n = " << n << " has tow answer: " << ans1 << "(DFS), " << ans2 << "(Recursive)" << endl;
		else cout << (cache[n] = ans1 + 1) - 1 << endl;
	}
	
	return 0;
}