这篇博客介绍了八皇后问题的不同变体，包括经典n皇后问题、特定皇后串求解、求最大数字和、2n皇后问题以及受限皇宫中的皇后摆放。通过深度优先搜索（DFS）策略解决这些问题，并提供了C++实现的代码示例。每个变体的解法都着重于避免皇后间的冲突，确保它们不在同一行、列或对角线上。
八皇后问题是dfs的经典问题，目前遇到过的类型大致有这么几种：
1.经典n皇后问题
题目描述
n−皇后问题是指将 n 个皇后放在 n×n 的国际象棋棋盘上，使得皇后不能相互攻击到，即任意两个皇后都不能处于同一行、同一列或同一斜线上。
输入格式
现在给定整数 n，请你输出所有的满足条件的棋子摆法。
输出格式
每个解决方案占 n 行，每行输出一个长度为 n 的字符串，用来表示完整的棋盘状态。
其中 . 表示某一个位置的方格状态为空，Q 表示某一个位置的方格上摆着皇后。
每个方案输出完成后，输出一个空行。
注意：行末不能有多余空格。
输出方案的顺序任意，只要不重复且没有遗漏即可。
输入样例
4
输出样例
.Q..
...Q
Q...
..Q.
..Q.
Q...
...Q
.Q..
分析
设置三个数组 col[N],dg[N],udg[N]; 判断每一列，每一个对角线，反对角线上是否放了皇后。
C++ 代码
#include<bits/stdc++.h>
using namespace std;
const int N = 20;
int n;
char path[N][N];
bool col[N],dg[N],udg[N];
void dfs(int x)
{
if(x == n)
{
for(int i=0;i<n;i++)
{
printf("%s\n",path[i]);
}
printf("\n");
return ;
}
for(int i=0;i<n;i++)
{
if(!col[i] && !dg[x+i] && !udg[n-x+i])
{
path[x][i]='Q';
col[i]=dg[x+i]=udg[n-x+i] = true;
dfs(x+1);
path[x][i]='.';
col[i]=dg[x+i]=udg[n-x+i] = false;
}
}
}
int main()
{
cin>>n;
for(int i=0;i<n;i++)
{
for(int j=0;j<n;j++)
{
path[i][j]='.';
}
}
dfs(0);
return 0;
}
2.八皇后
题目描述
会下国际象棋的人都很清楚：皇后可以在横、竖、斜线上不限步数地吃掉其他棋子。
如何将 8 个皇后放在棋盘上（有 8×8 个方格），使它们谁也不能被吃掉！
这就是著名的八皇后问题。
对于某个满足要求的 8 皇后的摆放方法，定义一个皇后串 a 与之对应，即 a=b1b2…b8，其中 bi 为相应摆法中第 i 行皇后所处的列数。
已经知道 8 皇后问题一共有 92 组解（即 92 个不同的皇后串）。
给出一个数 b，要求输出第 b 个串。
串的比较是这样的：皇后串 x 置于皇后串 y 之前，当且仅当将 x 视为整数时比 y 小。
输入格式
第一行包含整数 n，表示共有 n 组测试数据。
每组测试数据占 1 行，包括一个正整数 b。
输出格式
输出有 n 行，每行输出对应一个输入。
输出应是一个正整数，是对应于 b 的皇后串。
输入样例
2
1
92
输出样例
15863724
84136275
分析
由题意可得，一共存在92中合法性情况，所以只需要将这92次都先存储在结果数组中，之后直接输出即可。
C++ 代码
#include<bits/stdc++.h>
using namespace std;
const int N =20;
bool col[N],dg[N],udg[N];
int n,x;
vector<string> path;
void dfs(int u,string s)
{
if(u==8)
{
path.push_back(s);
return ;
}
for(int i=0;i<8;i++)
{
if(!col[i] && !dg[u+i] && !udg[u-i+8])
{
col[i]=dg[u+i]=udg[u-i+8]=1;
s+=(i+'1');
dfs(u+1,s);
s.pop_back();
col[i]=dg[u+i]=udg[u-i+8]=0;
}
}
}
int main()
{
dfs(0,"");
sort(path.begin(),path.end());
cin>>n;
while(n--)
{
cin>>x;
cout<<path[x-1]<<endl;
}
return 0;
}
3.八皇后*改
题目描述
规则同8皇后问题，但是棋盘上每格都有一个数字，要求八皇后所在格子数字之和最大。
输入格式
一个8*8的棋盘。
数据规模和约定
棋盘上的数字范围0~99
输出格式
所能得到的最大数字和
输入样例
1 2 3 4 5 6 7 8
9 10 11 12 13 14 15 16
17 18 19 20 21 22 23 24
25 26 27 28 29 30 31 32
33 34 35 36 37 38 39 40
41 42 43 44 45 46 47 48
48 50 51 52 53 54 55 56
57 58 59 60 61 62 63 64
输出样例
260
分析
由经典八皇后问题可得，一共存在92中合法性情况，所以只需要将这92次的结果取最大值就可以了。
C++ 代码
#include<bits/stdc++.h>
using namespace std;
int ans,g[10][10];
bool col[10],dg[20],udg[20];
void dfs(int u,vector<int> v)
{
if(u==8)
{
int res=0;
for(int i=0;i<8;i++)
{
res+=g[i][v[i]];
}
ans=max(res,ans);
}
for(int i=0;i<8;i++)
{
if(!col[i] && !dg[u+i] && !udg[u-i+8])
{
col[i]=dg[u+i]=udg[u-i+8]=1;
v.push_back(i);
dfs(u+1,v);
v.pop_back();
col[i]=dg[u+i]=udg[u-i+8]=0;
}
}
}
int main()
{
for(int i=0;i<8;i++)
{
for(int j=0;j<8;j++)
cin>>g[i][j];
}
vector<int> v;
dfs(0,v);
cout<<ans;
return 0;
}
4.2n皇后问题
题目描述
给定一个n*n的棋盘，棋盘中有一些位置不能放皇后。现在要向棋盘中放入n个黑皇后和n个白皇后，使任意的两个黑皇后都不在同一行、同一列或同一条对角线上，任意的两个白皇后都不在同一行、同一列或同一条对角线上。
问总共有多少种放法？
n小于等于8。
说明：同一条对角线是指包括两条主对角线的所有对角线，n=5时的棋盘从左上往右下有9条对角线，从右上往左下也有9条对角线。
比如，棋盘为：
1 1 1 1
1 1 1 1
1 1 1 1
1 1 1 1
表示一个4*4的棋盘，所有位置都可放皇后。
则可知有2种放法。
输入格式
输入的第一行为一个整数n，表示棋盘的大小。
接下来n行，每行n个0或1的整数，如果一个整数为1，表示对应的位置可以放皇后，如果一个整数为0，表示对应的位置不可以放皇后。
输出格式
输出一个整数，表示总共有多少种放法。
输入样例
4
1 0 1 1
1 1 1 1
1 1 1 1
1 1 1 1
输出样例
0
分析
本题与八皇后*改题目类似，不过要进行两次皇后摆放，一次摆黑色皇后(染色为2)，一次摆白色皇后(染色为3)，最后判断是否所有的n个黑皇后和n个白皇后都摆在了正确的位置上，若正确，就算作一次合法样例，ans++。
C++ 代码
#include<bits/stdc++.h>
using namespace std;
const int N = 10;
bool colb[N],dgb[N*2],udgb[N*2],colw[N],dgw[N*2],udgw[N*2];
int n,g[N][N],cntb,cntw,ans;
void dfsw(int u,int color) //后给白色皇后摆放染色
{
if(u==n) //摆完了判断是否为合法方案
{
if(cntb==n && cntw==n) ans++;
return ;
}
for(int i=0;i<n;i++)
{
if(!colw[i] && !dgw[u+i] && !udgw[u-i+n] && g[u][i]==1)
{
colw[i]=dgw[u+i]=udgw[u-i+n]=1;
int t=g[u][i];
g[u][i]=3;
cntw++;
dfsw(u+1,3);
cntw--;
g[u][i]=t;
colw[i]=dgw[u+i]=udgw[u-i+n]=0;
}
}
}
void dfsb(int u,int color) //先给黑色皇后摆放染色
{
if(u==n) //摆完了黑色就摆白色
{
dfsw(0,3);
return ;
}
for(int i=0;i<n;i++)
{
if(!colb[i] && !dgb[u+i] && !udgb[u-i+n] && g[u][i]==1)
{
colb[i]=dgb[u+i]=udgb[u-i+n]=1;
int t=g[u][i];
g[u][i]=2;
cntb++;
dfsb(u+1,2);
cntb--;
g[u][i]=t;
colb[i]=dgb[u+i]=udgb[u-i+n]=0;
}
}
}
int main()
{
cin>>n;
for(int i=0;i<n;i++)
{
for(int j=0;j<n;j++)
{
cin>>g[i][j];
}
}
dfsb(0,2);
cout<<ans;
return 0;
}
5.王、后传说
题目描述
地球人都知道，在国际象棋中，后如同太阳，光芒四射，威风八面，它能控制横、竖、斜线位置。
看过清宫戏的中国人都知道，后宫乃步步惊心的险恶之地。各皇后都有自己的势力范围，但也总能找到相安无事的办法。
所有中国人都知道，皇权神圣，伴君如伴虎，触龙颜者死…
现在有一个n*n的皇宫，国王占据他所在位置及周围的共9个格子，这些格子皇后不能使用（如果国王位于王宫的边缘，占用的格子可能不到9个）。当然，皇后也不会攻击国王。
现在知道了皇宫的规模n，国王的位置（x,y）（国王位于第x行第y列，行和列号从1开始），请问，有多少种方案放置n个皇后，使她们不能互相攻击（同一横线、竖线、斜线上只能有一个皇后）。
输入格式
输入仅一行，包含三个整数，表示皇宫的规模n（n<=12）及国王的位置x和y坐标。
输出格式
一个整数，表示放置n个皇后的方案数
输入样例
8 2 2
输出样例
10
分析
本题属于棋盘有限制的皇后问题，国王所在的九宫格可以提前标记为1，不能防置，其他位置可以随便摆放皇后，如果摆到最后一行发现正好摆好了n个皇后，则属于一种合法情况。
C++ 代码
#include<bits/stdc++.h>
using namespace std;
const int N=30;
int n,a,b,cnt,ans;
bool col[N],dg[N],udg[N],st[N][N];
void dfs(int u)
{
if(u==n) //摆到最后刚好n个皇后
{
if(cnt==n) ans++;
return ;
}
for(int i=0;i<n;i++)
{
if(!col[i] && !st[u][i] && !dg[u+i] && !udg[u-i+n]) //此地可以摆皇后
{
col[i]=dg[u+i]=udg[u-i+n]=1;
cnt++;
dfs(u+1);
cnt--;
col[i]=dg[u+i]=udg[u-i+n]=0;
}
}
}
int main()
{
cin>>n>>a>>b;
a--,b--; //题目从1~n，我们默认0~n-1，坐标偏移一下
for(int i=-1;i<=1;i++) //把皇帝的地盘提前标记好
{
for(int j=-1;j<=1;j++)
{
int x=a+i,y=b+j;
if(x>=0 && x<n && y>=0 && y<n) st[x][y]=1;
}
}
dfs(0);
cout<<ans;
return 0;
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
