洛谷 P1896 [SCOI2005]互不侵犯（状压dp）

题目描述

题目地址：P1896 [SCOI2005]互不侵犯

在N×N的棋盘里面放K个国王，使他们互不攻击，共有多少种摆放方案。国王能攻击到它上下左右，以及左上左下右上右下八个方向上附近的各一个格子，共8个格子。
输入格式
只有一行，包含两个数$N，K（1<=N<=9,0<=K<=N\ast 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\ast N}$。N取最大值9，则$2^{N\ast N}=2^{81}\approx 2\ast 10^{24}$,超时是肯定的。

／／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$，表示该行从右往左第2个、第4个位置上放置了国王；数字15对应二进制$(1111{)}_2$,表示从右往左前4个位置都放了国王；数字42对应二进制$(101010{)}_2$表示该行从右往左第2个，第4个、第6个位置放置了国王。假如棋盘的行宽为N,则从1到（1<<N）-1的数字就可以不重不漏地表示所有可能的放置状态。若对此有疑惑可以看一下->这篇博客理解一下。总之，要知道“从1到（1<<N）-1的数字就可以表示所有可能的放置状态”。
2.对于某个数字，其代表的放置状态可能不合法。如11的二进制为$(1011{)}_2$，代表的放置状态中有两个国王冲突。那如何检查一个数字代表的放置状态是否合法？若数$x$的二进制有两个相邻的1则不合法，于是可将其右移一位与原数按位与即可判断是否合法。即$x\&(x<<1)$为$0$则不冲突，否则冲突。
3.对于两个代表上下行关系的数字$x$和$y$，如何判断是否冲突：若$x\&y$为0则两行不会发生正上方和正下方的冲突,$x\&(y<<1)$和$(x<<1)\&y$都为$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$对应二进制中1的个数？看一下->这篇博客。
5.边界处理：在第一行中，放置状态为s且刚好放置了get(s)个国王的方案数是1种。即dp[1][s][get(s)]=1。
6.时间复杂度分析：程序有四层循环，分别是第一层对行的枚举(N行)、第二层对当前行放置状态s的枚举(共$2^N$种状态)，第三层对上一行放置状态的枚举（共$2^N$种状态），第四层对放置国王数k的枚举(共K个)。时间复杂度粗略为$NK\ast 2^{2N}$,N最大取9，K最大取81，$NK\ast 2^{2N}=9^3\ast 2^{18}\approx 10^8$,可见时间复杂度得到了很大的优化。
7.最终答案$res={\sum }_{s=0}^{(1<<N)-1}dp[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;
     }