N皇后问题（C++ tag路径回溯）

最新推荐文章于 2024-09-17 18:35:56 发布
最新推荐文章于 2024-09-17 18:35:56 发布
阅读量439 收藏
点赞数
文章标签： c++ 深度优先 图搜索算法 算法 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yang7654/article/details/122639757
版权

横纵斜不能有冲突

*暴力方法：全局搜索空间是N^2，即栈中的安全皇后放好后，下一个皇后的搜索路径仍然是原矩阵。

*剪枝后排除一部分不需要的遍历操作，将剩余遍历空间缩短至N!

tag数组负责记录当前的路径，和DFS中带路径的那个方法几乎一致，只不过回溯的结果是全部解（有多少个解的问题），之前写的那个单纯的dfs只需要找到一个有效解（即有没有解的问题）

下面给出N皇后（Leetcode51）的解法：

1.未优化版本（N*N超级暴力破解）

//自己最先想到并实现了的（按照全搜索空间全排列超级暴力搜，vs2015 + i7 3960X @3.7Ghz 默认频率（6皇后100ms，7皇后52s时间  8皇后需要36min
void dfsqueen3_1(int n, vector<vector<int>>&tag, vector<vector<string>>&ret) {
	//每一个子递归函数都采用N*N的搜索空间进行一个一个找吧，先弄出来一个版本再说（暴力）
	if (tag.size() == n)
	{
		int jb = 0;
		while (jb < n) {
			if (tag[jb][0] != jb++)
				return;
		}
		vector<string>vs;
		string c(n, '.');
		for (int i = 0; i < tag.size(); ++i) {
			c[tag[i][1]] = 'Q';
			vs.push_back(c);
			c[tag[i][1]] = '.';
		}
		ret.push_back(vs);
	}
	for (int q = 0; q < n; ++q)
	{
		for (int v = 0; v < n; ++v) //这一行的所有列递归完毕后
		{
			//判断是否满足条件
			int gk = 0;
			for (int i = 0; i < tag.size(); ++i) //判断此时的皇后是否互相攻击	
			{
				if ((q == tag[i][0] || v == tag[i][1] || q - tag[i][0] == v - tag[i][1] || q - tag[i][0] == tag[i][1] - v))
				{
					gk = 1;
					break;
				}
			}
			if (gk == 0)
			{
				tag.push_back({ q,v });//并未相互攻击，此时的坐标有效，加入路径	
				dfsqueen3_1(n, tag, ret);
				tag.pop_back();
			}

		}		

	}

}

以上方法可以说是非常暴力了，全局复杂度超级大，因为做出了很多重复工作，搞出来的解是四个方向均进行遍历的，也就是说四个方向数组的全排列过程，虽说对于该题而言方法不是很优秀，但是这种思想是有效的。

2.下面给出优化后的第一个版本

//get better2(9-QUEEN: 92s)
void dfsqueen3_2(int n, vector<vector<int>>&tag, vector<vector<string>>&ret,unordered_set<int>&rowset, unordered_set<int>&colset) {
	//
	if (tag.size() == n)
	{
		vector<string>vs;
		string c(n, '.');
		for (int i = 0; i < tag.size(); ++i) 
		{
			c[tag[i][1]] = 'Q';
			vs.push_back(c);
			c[tag[i][1]] = '.';
		}
		ret.push_back(vs);

	}
	for (int q = tag.size(); q < n; ++q)
	{		
		if (rowset.find(q) != rowset.end() && rowset.size() != 0) {
			continue;
		}
		for (int v = 0; v < n; ++v) //这一行的所有列递归完毕后
		{
			if ((colset.find(v) != colset.end()) && colset.size() != 0) {
				continue;
			}
			//判断是否满足条件
			int gk = 0;
			for (int i = 0; i < tag.size(); ++i) //判断此时的皇后是否互相攻击	
			{
				if (q - tag[i][0] == v - tag[i][1] || q - tag[i][0] == tag[i][1] - v)
				{
					gk = 1;
					break;
				}
			}
			//剪枝思想：如果第三行试过了所有方案都无法插入，那么第二行的选择肯定有问题，此时无需进入第四行了，直接返回第二行修改后再继续
			if (gk == 1 && v == n-1) { return; }//这一行剪一波
			if (gk == 0)
			{
				tag.push_back({ q,v });//并未相互攻击，此时的坐标有效，加入路径	
				if (tag[0][0] != 0)return;
				rowset.insert(q);
				colset.insert(v);
				dfsqueen3_2(n, tag, ret,rowset,colset);
				tag.pop_back();
				rowset.erase(q);
				colset.erase(v);
			}
		}
	}
}

 get better2方法在row搜索时将二重循环中的row搜索过程从七点0，变为了tag中的元素个数，也就是说如果tag中有3个元素，那么前三行是不用去搜索判断的，直接从第四行的所有列进行寻找即可，免去了row的一部分判断过程；第二，该方法在判断完一行的所有列之后进行了tag检查，也就是说如果一行的所有列都没有能满足的位置，那么这一行无效，下面的行统统不需要判断了，大大减少了计算量。

3.下面给出优化后的get better3版本

void dfsqueen3_3(int n, vector<vector<int>>&tag, vector<vector<string>>&ret, vector<int>&rowset, vector<int>&colset) {
	//
	if (tag.size() == n)
	{
		vector<string>vs;
		string c(n, '.');
		for (int i = 0; i < tag.size(); ++i)
		{
			c[tag[i][1]] = 'Q';
			vs.push_back(c);
			c[tag[i][1]] = '.';
		}
		ret.push_back(vs);
	}

	for (int q = tag.size(); q < n; ++q)
	{
		if (rowset[q] != 0) {
			continue;
		}
		for (int v = 0; v < n; ++v) //这一行的所有列递归完毕后
		{
			if (colset[v] != 0) {
				continue;
			}
			//判断是否满足条件
			int gk = 0;
			for (int i = 0; i < tag.size(); ++i) //判断此时的皇后是否互相攻击	
			{
				if (q - tag[i][0] == v - tag[i][1] || q - tag[i][0] == tag[i][1] - v)
				{
					gk = 1;
					break;
				}
			}
			//剪枝思想：如果第三行试过了所有方案都无法插入，那么第二行的选择肯定有问题，此时无需进入第四行了，直接返回第二行修改后再继续
			if (gk == 1 && v == n - 1) { return; }//这一行剪一波
			if (gk == 0)
			{
				//并未相互攻击，此时的坐标有效，加入路径	
				tag.push_back({ q,v });
				if (tag[0][0] != 0)return;
				rowset[q] = 1;
				colset[v] = 1;
				dfsqueen3_3(n, tag, ret, rowset, colset);
				tag.pop_back();
				rowset[q] = 0;
				colset[v] = 0;
			}

		}
	}

}

第三个版本把第二版中的哈希表unordered_set集合用vector来替代了，vector寻址的优势体现出来了。其他的没有做出改动

4.第四个版本（纯C数组优化常数时间）

//get better4(9-QUEEN: 18.139s  优化vector至普通数组，常数时间？)
void dfsqueen3_4(int n, vector<vector<int>>&tag, vector<vector<string>>&ret, int(&rowset)[10], int(&colset)[10]) {
	//
	if (tag.size() == n)
	{
		vector<string>vs;
		string c(n, '.');
		for (int i = 0; i < tag.size(); ++i)
		{
			c[tag[i][1]] = 'Q';
			vs.push_back(c);
			c[tag[i][1]] = '.';
		}
		ret.push_back(vs);
	}

	for (int q = tag.size(); q < n; ++q)
	{
		if (rowset[q] != 0) {
			continue;
		}
		for (int v = 0; v < n; ++v) //这一行的所有列递归完毕后
		{
			if (colset[v] != 0) {
				continue;
			}
			//判断是否满足条件
			int gk = 0;
			for (int i = 0; i < tag.size(); ++i) //判断此时的皇后是否互相攻击	
			{
				if (q - tag[i][0] == v - tag[i][1] || q - tag[i][0] == tag[i][1] - v)
				{
					gk = 1;
					break;
				}
			}
			//剪枝思想：如果第三行试过了所有方案都无法插入，那么第二行的选择肯定有问题，此时无需进入第四行了，直接返回第二行修改后再继续
			if (gk == 1 && v == n - 1) { return; }//这一行剪一波
			if (gk == 0)
			{
				//并未相互攻击，此时的坐标有效，加入路径	
				tag.push_back({ q,v });
				if (tag[0][0] != 0)return;
				rowset[q] = 1;
				colset[v] = 1;
				dfsqueen3_4(n, tag, ret, rowset, colset);
				tag.pop_back();
				rowset[q] = 0;
				colset[v] = 0;
			}

		}
	}

}

纯方括号数组的引用，看起来很不错，不过在小范围数字内，这种方法没有比vector方法取得足够令人满意的效果。这俩只相差了几ms，几乎可以看作是误差。

5.降维（根据一开始的思路， 不遍历row了，只遍历col，把row当成形参加入递归函数）

class Solution {
public:
void dfs(int n,int row,vector<vector<int>>&tag,vector<vector<string>>&ret,int(&colset)[10]) {
	if (tag.size() == n) {
		vector<string>vs;
		string c(n,'.');
		for (int i = 0; i < tag.size(); ++i) {
			c[tag[i][1]] = 'Q';
			vs.push_back(c);
			c[tag[i][1]] = '.';
		}
		ret.push_back(vs);
	}
	for (int v = 0; v < n; ++v) {
		if (colset[v] == 1)continue;
		int mute = 0;
		for (int i = 0; i < tag.size(); ++i) {
			if (row - tag[i][0] == v - tag[i][1] || row - tag[i][0] == tag[i][1] - v) {
				mute = 1;
				break;
			}
		}
		if (mute == 0) {
			tag.push_back({ row,v });
			colset[v] = 1;
			dfs(n,row+1,tag,ret,colset);
			tag.pop_back();
			colset[v] = 0;
		}
	}
}
vector<vector<string>> solveNQueens(int n) {
	vector<vector<string>>ret;
	vector<vector<int>>tag;
	int pc[10]{ 0,0,0,0,0,0,0,0,0,0 };
	dfs(n, 0,tag, ret, pc);
	return ret;
}
};

 显然，优化至目前的情况并非是最佳的，因为斜线上的皇后攻击判断仍然是每次递归后与所有tag中的元素判断，并不是O(1)复杂度的直接寻址，但是更优解法目前先不搞了。以后有机会再写。

Novigard
关注
C++ 用回溯法解决N皇后问题
weixin_44208324的博客
03-14 3335
N皇后问题是计算机科学中最为经典的问题之一。1848年，国际西洋棋起手马克思·贝瑟尔提出了8皇后问题。 将N个皇后摆放在N*N的棋盘中，互相不可攻击，有多少种摆放方式，每种摆放方式具体是怎样的？ #include<vector> #include<string> class Solution { public: Solution() {}; ~Solution() {}...
【n皇后问题】c++\c语言解n皇后问题（回溯法）
ChenXiaoshui_的博客
03-28 2719
代码不懂可以看注释，还是较容易理解的，利用flag可以防止不必要的递归。 #include<stdio.h> #include<math.h> int P[10]={0}; //此列的皇后为第几行 int n = 4; //几皇后 bool hashTable[10]={false}; //此行没皇后 void generateP(int index){ if(index == n+1){ for(int i=1;i<=
c++ 用回溯法解决经典的N皇后问题
04-14
c++ 算法学习 用回溯法解决经典的N皇后问题。
n皇后问题—回溯法 C++实现
areen7003的博客
09-02 966
#include <iostream> #include <vector> using namespace std; bool isLegal(int row,int col,vector<string> &v,int n) { for(int i=0;i<row;++i) if(v[i][col...
n皇后问题（递归算法）c/c++
最新发布
2301_79317939的博客
09-17 473
/存放各皇后所在的列号,即(i,q[i])为一个皇后位置。bool place(int i,int j) //测试(i,j)位置能否摆放皇后。void dispasolution(int n) //输出n皇后问题的一个解。while (k<i) //k=1～i-1是已放置了皇后的行。//放置1～i的皇后。//n为存放实际皇后个数。y ++ )//遍历y。//为了方便理解，把i的值付给x。if(place(x,y))//如果满足。
n皇后问题（C++/C语言实现）回溯法
milk_aquarium的博客
11-01 8931
问题描述和要求 按照国际象棋的规则，一个皇后可以攻击与之处在同一行或是同一列或同一条斜线上的其他任何棋子。则n皇后问题的要求为，在一个n×n的棋盘上放置n个皇后，使得任何两个皇后不能被放在同一行或同一列或同一条斜线上。 回溯法原理 回溯法可以系统地搜索一个问题的所有解或任一解。它在包含所有问题的解空间树中，按照深度优先策略，从根节点出发搜索解空间树。算法搜索至解空间树的任一结点时，总是先判断该结点是否肯定不包含问题的解。如果肯定不包含，则跳过对以该结点为根的子树的系统搜索，逐层向其祖先回溯；否则，进入该子树
ACWing n-皇后问题
Stillboring的博客
04-01 2097
n−n−皇后问题是指将nn个皇后放在n×nn×n的国际象棋棋盘上，使得皇后不能相互攻击到，即任意两个皇后都不能处于同一行、同一列或同一斜线上。 现在给定整数nn，请你输出所有的满足条件的棋子摆法。 输入格式 共一行，包含整数nn。 输出格式 每个解决方案占nn行，每行输出一个长度为nn的字符串，用来表示完整的棋盘状态。 其中.表示某一个位置的方格状态为空，Q表示某一个位置的方格上摆着皇后。 每个方案输出完成后，输出一个空行。 注意：行末不能有多余空格。 输出方...
C++基于回溯法解决八皇后问题示例
12-31
本文实例讲述了C++基于回溯法解决八皇后问题的方法。分享给大家供大家参考，具体如下： 回溯法的基本做法是搜索，或是一种组织得井井有条的，能避免不必要搜索的穷举式搜索法。这种方法适用于解一些组合数相当大的...
回溯算法解决N皇后问题C++.pdf
06-01
在C++编程语言中，使用回溯算法解决N皇后问题通常会采用递归函数，以及必要的辅助函数来帮助判断皇后是否可以放置在棋盘的某一位置上。在给定的代码示例中，一个`Queen`类被设计用来表示问题的当前状态，其中包含了...
N皇后问题C++
01-12
利用回溯法求解N皇后问题（N的值不能小于4，小于4无解），定义三个函数，一个用于判断安置元素的合法性，一个用于递归安置元素，还有一个用于显示皇后安置问题的布局，用一个main函数实现代码功能。输入N值，显示出N...
C++ 回溯算法（解决n皇后问题）
weixin_53064820的博客
03-08 743
/ 设置皇后linen,i的控制区。// 取消设置linen,i的控制区。// 设置y以下的控制区。// 设置y以下的控制区。// 设置y以上的控制区。// 设置y以上的控制区。//设置皇后linen ,i 位置的控制区。// 设置x的控制区。// 设置x的控制区。//取消设置皇后linen,i的控制区。
回溯法解决n皇后问题纯c++编写
02-23
由input.txt,output.txt,n皇后问题.cpp组成，纯c++编写。保证运行通过！
n皇后问题(回溯法，C++)
05-23
n皇后问题相信大家早已熟悉了，用回溯法解，那是相当的简单。
n皇后问题 C++
m0_61629480的博客
05-26 1760
先上代码！ #include<iostream> using namespace std; const int N = 20; int n; bool row[N],col[N], dg[N], udg[N]; char g[N][N]; void dfs(int x, int y, int z) { if (y == n) y = 0, x++; //判断y是否已经抵达边界，抵达后，x+1进行下一行 if (x == n) { if (z =
n-皇后问题(c++)
chq66666的博客
05-21 1456
𝑛−皇后问题是指将 𝑛 个皇后放在 𝑛×𝑛 的国际象棋棋盘上，使得皇后不能相互攻击到，即任意两个皇后都不能处于同一行、同一列或同一斜线上。现在给定整数 𝑛，请你输出所有的满足条件的棋子摆法。
n皇后问题C++
m0_73879061的博客
05-30 158
【代码】n皇后问题C++
N皇后问题 c++
han199341lu的专栏
02-27 938
/* 功能: 求解放置n皇后方案的个数。 输入： 无 返回： int：放置n皇后方案的个数 */ int PlaceQueenMethodNum(int n) { int matrix[100]={0};//皇后放置的列数 int sum=0;//可行解的个数 if(n<=3) { return 0; } queen(1,n,sum,matrix); //pr
N皇后问题c++
LuckZY_的博客
10-13 2220
题目描述（洛谷P1219） 一个如下的6×6的跳棋棋盘，有六个棋子被放置在棋盘上，使得每行、每列有且只有一个，每条对角线（包括两条主对角线的所有平行线）上至多有一个棋子。 上面的布局可以用序列246135来描述，第i个数字表示在第i行的相应位置有一个棋子，如下： 行号1\ 2\ 3\ 4\ 5\ 6 列号2\ 4\ 6\ 1\ 3\ 5 这只是棋子放置的一个解。请编一个程序找出所有棋子放置的解。 并把它们以上面的序列方法输出，解按字典顺序排列。 请输出前3个解。最后一行是...
C++实现n皇后问题的回溯法解法
总结起来，这个C++程序利用回溯法巧妙地解决了n皇后问题，展示了递归策略如何在有限空间中寻找复杂问题的解决方案。理解并实现这种算法有助于提高编程技巧，尤其是在处理需要穷举所有可能性的问题时。通过编写和调试...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值