题目描述
在N×N的棋盘里面放K个国王,使他们互不攻击,共有多少种摆放方案。国王能攻击到它上下左右,以及左上左下右上右下八个方向上附近的各一个格子,共8个格子。
输入格式
只有一行,包含两个数
N
,
K
(
1
<
=
N
<
=
9
,
0
<
=
K
<
=
N
∗
N
)
N,K ( 1 <=N <=9, 0 <= K <= N * N)
N,K(1<=N<=9,0<=K<=N∗N)
输出格式
所得的方案数
输入输出样例
输入
3 2
输出
16
深度优先搜索70分做法:
本着能暴搜就写个暴搜骗骗分的原则,上来就写个dfs。暴力搜索还是要熟练,想不到优化的正解也有分拿!
1.逐行从左到右放置国王,每到一个新的格子(x,y)都有两种选择:放置或者不放置。假如此处放置会产生冲突,就只能选择不放置,即只用递归搜索不放置的情况。假如此处放置国王不会和之前的放置产生冲突,则需要对放置和不放置两种情况进行搜索。
2.一些细节处理:
(1)由于是逐行从左到右放置,只需检查左上方、正上方、右上方、正左方这四个方向是否已经放置了国王。
(2)将dfs的起点设为(0,N),并在递归的入口处判断当前位置是否在一行的末尾:若在一行的末尾则需要跳往下一行,否者继续往右放置。这样做的好处在于可以实现对位置(1,1)处放与不放两种情况的搜索。另外,只有在“放置了k个国王”、“已经不能放国王”、“放到(N,N)处还没有放满k个国王”这几种情况下才递归返回,若不在递归入口处将位置改为“合法位置”,而是把越界后的位置当成一个搜索状态并return的话,那整个搜索的状态就被破坏了。假如画一下dfs的搜索树,就会发现这个问题。(可以类比简单的迷宫问题中对越界的处理来理解,不理解对本题也没有影响 )。
3.时间复杂度粗略估计:不考虑因为“已经放置了k个国王”而产生的递归返回和“某些位置只能选择不放”的情况,那么每个格子有两种选择,即时间复杂度为
2
N
∗
N
2^{N*N}
2N∗N。N取最大值9,则
2
N
∗
N
=
2
81
≈
2
∗
1
0
24
2^{N*N}=2^{81} \approx2*10^{24}
2N∗N=281≈2∗1024,超时是肯定的。
//C++暴搜代码,细节见注释:
#include<iostream>
using namespace std;
typedef long long LL;
int grid[20][20]; //存储棋盘状态,grid[x][y]为1表示放置国王,为0表示不放
int N,K;
LL res=0; //记录方案数
//判断位置(x,y)是否可以放置
bool check(int x,int y){
if(!grid[x-1][y]&&!grid[x][y-1]&&!grid[x-1][y-1]&&!grid[x-1][y+1]) return true;
return false;
}
//dfs参数说明:当前位置为(x,y),已经放置国王数为k
void dfs(int x,int y,int k){
if(k==K){res++;return;} //放足K个国王,方案数增加
if(y==N){x++;y=1;} //到达一行的末尾则跳往下一行第一列
else y++; //否则向右
if(x>N) return; //搜完整个棋盘,结束搜索
dfs(x,y,k); //搜索不放置的情况
if(check(x,y)){ //如果不冲突就尝试放置
grid[x][y]=1;
dfs(x,y,k+1); //搜索下一个状态
grid[x][y]=0; //回溯时撤销放置
}
}
int main(){
cin>>N>>K;
dfs(0,N,0);
cout<<res<<endl;
return 0;
}
状压dp满分正解
1.用一个二进制数字来表示某一行的国王放置情况:若第i位是1则表示位置i处放了国王,为0表示没有放置国王。 如数字10对应二进制为
(
1010
)
2
(1010)_{2}
(1010)2,表示该行从右往左第2个、第4个位置上放置了国王;数字15对应二进制
(
1111
)
2
(1111)_{2}
(1111)2,表示从右往左前4个位置都放了国王;数字42对应二进制
(
101010
)
2
(101010)_{2}
(101010)2表示该行从右往左第2个,第4个、第6个位置放置了国王。假如棋盘的行宽为N,则从1到(1<<N)-1的数字就可以不重不漏地表示所有可能的放置状态。若对此有疑惑可以看一下->这篇博客理解一下。总之,要知道“从1到(1<<N)-1的数字就可以表示所有可能的放置状态”。
2.对于某个数字,其代表的放置状态可能不合法。如11的二进制为
(
1011
)
2
(1011)_{2}
(1011)2,代表的放置状态中有两个国王冲突。那如何检查一个数字代表的放置状态是否合法?若数
x
x
x的二进制有两个相邻的1则不合法,于是可将其右移一位与原数按位与即可判断是否合法。即
x
&
(
x
<
<
1
)
x\&(x<<1)
x&(x<<1)为
0
0
0则不冲突,否则冲突。
3.对于两个代表上下行关系的数字
x
x
x和
y
y
y,如何判断是否冲突:若
x
&
y
x\&y
x&y为0则两行不会发生正上方和正下方的冲突,
x
&
(
y
<
<
1
)
x\&(y<<1)
x&(y<<1)和
(
x
<
<
1
)
&
y
(x<<1)\&y
(x<<1)&y都为
0
0
0则不会发生左(右)上方、左(右)下方的冲突。
4.确定状态转移方程:定义dp[i][s][k]为“当前放置到第i行,且当前行的放置状态为s,且当前已经放了k个国王”的方案数。接下来确定状态转移方程:正向思考可知由dp[i][s][k]可以递推到的状态为"放置到第i+1行,放置状态为ss,已经放置了kk个国王"的状态,其中ss为一个自身合法且与s无冲突的一个状态,而kk与k的关系为kk=k+ss对应二进制数中1的个数。定义函数get(x)返回x的二进制中1的个数(get(x)代表在x对应放置状态下该行放置国王的个数),则上述正向递推过程可以表示为dp[i+1][ss][k+get(ss)]+=dp[i][s][k]。逆向思考则确定最终的状态转移方程为dp[i][s][k]+=dp[i-1][ss][k-get(s)](此处的ss代表第i-1行的放置状态)。如何获取数
x
x
x对应二进制中1的个数?看一下->这篇博客。
5.边界处理:在第一行中,放置状态为s且刚好放置了get(s)个国王的方案数是1种。即dp[1][s][get(s)]=1。
6.时间复杂度分析:程序有四层循环,分别是第一层对行的枚举(N行)、第二层对当前行放置状态s的枚举(共
2
N
2^{N}
2N种状态),第三层对上一行放置状态的枚举(共
2
N
2^{N}
2N种状态),第四层对放置国王数k的枚举(共K个)。时间复杂度粗略为
N
K
∗
2
2
N
NK*2^{2N}
NK∗22N,N最大取9,K最大取81,
N
K
∗
2
2
N
=
9
3
∗
2
18
≈
1
0
8
NK*2^{2N}=9^{3}*2^{18} \approx10^{8}
NK∗22N=93∗218≈108,可见时间复杂度得到了很大的优化。
7.最终答案
r
e
s
=
∑
s
=
0
(
1
<
<
N
)
−
1
d
p
[
N
]
[
s
]
[
K
]
res=\sum_{s=0}^{(1<<N)-1} dp[N][s][K]
res=∑s=0(1<<N)−1dp[N][s][K],即所有放置到最后一行且刚好放了K个国王的状态下的方案都合法,累加这些方案数即可。
#include<iostream>
using namespace std;
const int n=12;
typedef long long LL;
LL dp[n][1<<n][n*n];
int get(int x){ //返回x对应的二进制中1的个数
int cnt=0;
while(x){
x-=x&(-x); //减去最低位的1
cnt++;
}
return cnt;
}
//判断数x是否是合法的放置状态
int check1(int x){
return (x&(x<<1))==0;
}
//判断x和y代表的放置状态是否冲突
int check2(int x,int y){
if(x&y) return 0;
if((x<<1)&y) return 0;
if(x&(y<<1)) return 0;
return 1;
}
int main(){
int N,K;
cin>>N>>K;
for(int i=1;i<=N;i++){ //逐行放置
for(int s=0;s<(1<<N);s++){ //枚举所有可能的放置状态
if(check1(s)){ //若s为合法的放置状态
if(i==1) {dp[i][s][get(s)]=1;} //边界处理
else{
for(int ss=0;ss<(1<<N);ss++){ //枚举上一行的放置状态
if(check2(s,ss)&&check1(ss)){ //检查当前行与上一行是否冲突
for(int k=get(s);k<=K;k++){
dp[i][s][k]+=dp[i-1][ss][k-get(s)];
}
}
}
}
}
}
}
//统计答案
LL res=0;
for(int s=0;s<(1<<N);s++) res+=dp[N][s][K];
cout<<res<<endl;
return 0;
}