n皇后问题和2n皇后问题

身为一只大二狗,表示很多东西都不会,包括n皇后问题之前理解的也不是很透彻,很羞愧的写下了这篇blog= =

n皇后问题( hdu-2553)

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

Input
共有若干行,每行一个正整数N≤10,表示棋盘和皇后的数量;如果N=0,表示结束。
Output
共有若干行,每行一个正整数,表示对应输入行的皇后的不同放置数量。
Sample Input
1
8
5
0
Sample Output
1
92
10

分析:n个皇后,每行放一个,同行同列同对角线都不能有两个皇后,说起思路,都知道是搜索回溯,可是要怎么搜索回溯呢?

第一步:检查是否n个皇后都已经放好,若已经放好,ans++;

第二步:若没有放好,准备放置第cur(起初cur=1)个皇后,从第一列开始检查,到第n列;

第三步:如果当前列可以放置第cur个皇后,搜索第cur+1个皇后;

第四步:如果当前列不能放置皇后的话,继续,如果第n列都不能放的话,则回溯到cur-1列;

#include<cstdio>
#include<cmath>
#include<cstring>
#include<algorithm>
#include<iostream>

using namespace std;
const int maxn = 13;
int nn;
int tmp;
int pos[maxn];
int ans[maxn];

bool check( int cur)
{
	for( int i = 1; i < cur; i++)
		if( pos[i] == pos[cur] || abs(i-cur) == abs(pos[i]-pos[cur]))
			return false;
	return true;

}

void dfs( int cur, int n)
{
	if( cur == n+1)
		tmp++;

	for( int i = 1; i <= n; i++)
	{
		pos[cur] = i;
		/*for( int j = 1; j < cur; j++)
		{
		      	if( pos[j] == pos[cur] && abs(j-cur) == abs(pos[j]-pos[cur]))
				dfs(cur+1);
		}*/
		if( check(cur))
			dfs(cur+1,n);
	}
}

int main()
{
	for( int i = 1; i < maxn; i++)
	{
		memset(pos,0,sizeof(pos));
		tmp = 0;
		dfs(1,i);
		ans[i] = tmp;
	}

	while( ~scanf("%d",&nn) && nn)
	{
		printf("%d\n",ans[nn]);
	}


	return 0;
}

2n皇后问题(wustoj-1291)

Description
给定一个n*n的棋盘,棋盘中有一些位置不能放皇后。现在要向棋盘中放入n个黑皇后和n个白皇后,使任意的两个黑皇后都不在同一行、同一列或同一条对角线上,任意的两个白皇后都不在同一行、同一列或同一条对角线上。问总共有多少种放法?n小于等于8。

Input
多组测试数据,每组数据的输入格式如下。
第一行为一个整数n,表示棋盘的大小。
接下来n行,每行n个0或1的整数,如果一个整数为1,表示对应的位置可以放皇后,如果一个整数为0,表示对应的位置不可以放皇后。
Output
输出一个整数,表示总共有多少种放法。

Sample Input
4
1 1 1 1
1 1 1 1
1 1 1 1
1 1 1 1
4
1 0 1 1
1 1 1 1
1 1 1 1
1 1 1 1

Sample Output
2
0

分析:这好像是某次蓝桥杯的一个题,当时以为2n皇后很复杂,其实也不,也跟n皇后差不多,但是2n皇后,要先去放好黑皇后(或白皇后),再去处理白皇后(或黑皇后),一次处理完之后ans++,具体步骤就不分析了,仔细体会~

#include<cstdio>
#include<cmath>
#include<cstring>
#include<algorithm>
#include<iostream>

using namespace std;
const int maxn = 10;
int n;
int mp[maxn][maxn];
int posb[maxn];
int posw[maxn];
int ans;

bool checkw( int cur)
{
	for( int i = 1; i < cur; i++)
		if( posw[i] == posw[cur] || abs(i-cur) == abs(posw[i]-posw[cur]))
			return false;
	return true;
}

bool checkb( int cur)
{
	for( int i = 1; i < cur; i++)
		if( posb[i] == posb[cur] || abs(i-cur) == abs(posb[i]-posb[cur]))
			return false;
	return true;
}

void dfs_white( int cur)
{
	if( cur == n+1)
	{
		ans++;
/*		printf("black:");
		for( int i = 1; i <= n; i++)
			printf("%d ",posb[i]);
		putchar(10);
		printf("white:");
		for( int i = 1; i <= n; i++)
			printf("%d ",posw[i]);
		putchar(10);*/
	}
	for( int i = 1; i <= n; i++)
	{
		if( posb[cur] == i)
			continue;
		if( mp[cur][i] == 0)
			continue;
		posw[cur] = i;
 		if( checkw(cur))
			dfs_white(cur+1);
	}
}

void dfs_black( int cur)
{
	if( cur == n+1)
	{
		dfs_white(1);
	}
	for( int i = 1; i <= n; i++)
	{
		if( mp[cur][i] == 0)
			continue;
		posb[cur] = i;
		if( checkb(cur))
			dfs_black(cur+1);
	}
}

int main()
{
	while( ~scanf("%d",&n) && n)
	{
		for( int i = 1; i <= n; i++)
			for( int j = 1; j <= n; j++)
				scanf("%d",&mp[i][j]);
		memset(posb,0,sizeof(posb));
		memset(posw,0,sizeof(posw));
		ans = 0;
		dfs_black( 1);
		printf("%d\n",ans);
	}

	return 0;
}




### 算法思路 2n皇后问题一个经典的组合优化问题,其核心目标是在一个 $ n \times n $ 的棋盘放置 $ n $ 个黑皇后 $ n $ 个白皇后,使得同一颜色的皇后之间攻击。具体来说,任意两个皇后或任意两个皇后不能在同一行、同一列或同一条对角线上。 解决这一问题的关键在于如何高效地搜索所有可能的放置方案,并确保满足上述条件。通常采用 **递归与回溯** 的方法来实现这一目标。 #### 回溯算法的核心思想 1. **逐行放置皇后**:由于每行只能放置一个皇后,因此可以从第一行开始,依次在每一行中尝试将皇后放置在某一列。 2. **冲突检测**:每次放置皇后时,必须检查该位置是否与之前已经放置的同色皇后发生冲突(即是否在同一列或对角线上)。 3. **递归调用**:如果当前位置合法,则进入下一行继续放置一个皇后。 4. **回溯机制**:如果某一行的所有列都无法放置皇后,则需要返回到上一层递归,调整上一行的皇后位置,重新尝试新的放置方式。 #### 2n皇后的特殊性 在2n皇后问题中,除了要处理黑皇后之间的冲突外,还需要同时处理白皇后之间的冲突。这意味着,在黑皇后完成放置后,再进行白皇后放置时,也需要确保白皇后的位置会与已有的白皇后发生冲突,并不能与黑皇后重叠[^3]。 --- ### 实现方法 以下是一个基于C++的实现示例,展示了如何通过递归回溯解决2n皇后问题: ```cpp #include <cmath> #include <iostream> using namespace std; #define M 20 int n; int p1[M] = {0}; // 黑皇后的位置数组 int p2[M] = {0}; // 白皇后的位置数组 int qi[M][M]; // 棋盘矩阵,0表示该位置放置 int sum = 0; // 解的数量 // 判断黑皇后是否冲突 int pd1(int h) { for (int i = 0; i < h; i++) { if ((p1[i] == p1[h]) || (abs(h - i) == abs(p1[i] - p1[h]))) return 0; } return 1; } // 判断白皇后是否冲突 int pd2(int h) { for (int i = 0; i < h; i++) { if ((p2[i] == p2[h]) || (abs(h - i) == abs(p2[i] - p2[h]))) return 0; } return 1; } // 放置皇后 void fang2(int h) { if (h == n) sum++; else { for (int i = 0; i < n; i++) { if (p1[h] == i) continue; // 不能与黑皇后重叠 if (qi[h][i] == 0) continue; // 该位置放置 p2[h] = i; if (pd2(h)) fang2(h + 1); } } } // 放置皇后 void fang1(int h) { if (h == n) fang2(0); // 黑皇后放完后开始放白皇后 else { for (int i = 0; i < n; i++) { if (qi[h][i] == 0) continue; // 该位置放置 p1[h] = i; if (pd1(h)) fang1(h + 1); } } } int main() { cin >> n; for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) cin >> qi[i][j]; } fang1(0); cout << sum; return 0; } ``` --- ### 算法优化建议 1. **剪枝策略**:在递归过程中,可以通过提前判断某些明显合法的位置来减少必要的计算。 2. **位运算优化**:对于较小的 $ n $ 值(如 $ n \leq 8 $),可以使用位运算来加速冲突检测过程。 3. **预处理棋盘**:对于给定的棋盘限制(如某些格子不能放置皇后),可以在初始化阶段就排除这些无效位置,避免重复判断。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值