状压dp - 棋盘问题（学习）

转载自：http://blog.youkuaiyun.com/math_coder/article/details/9671581

如果看不明白代码的位运算，请先了解下位运算的应用

---------------------------------------------------------------------------------------------------------------------------

**********此文章属于原创，看此文章前请先参考论文   周伟《动态规划之状态压缩》**********

问题1：

        在n*n(n≤20)的方格棋盘上放置n个车(可以攻击所在行、列)，求使它们不能互相攻击的方案总数。

如果用组合学的角度来考虑此问题，那么非常简单：

        我们一行一行放置，第一行有n种选择，第二行n-1，……，最后一行有1种选择，根据乘法原理，答案就是n!

这里我们介绍另一种解法：状态压缩递推(States Compressing Recursion,SCR)。

• 我们仍然一行一行放置。
• 取棋子的放置情况作为状态，某一列如果已经放置棋子则为1，否则为0。这样，一个状态就可以用一个最多20位的二进制数表示。
• 例如n=5,第1、3、4列已经放置，则这个状态可以表示为01101(从右到左)。设fs为达到状态s的方案数，则可以尝试建立f的递推关系。
• 考虑n=5,s=01101
• 因为我们是一行一行放置的，所以当达到s时已经放到了第三行。又因为一行能且仅能放置一个车，所以我们知道状态s一定来自： 

            ①前两行在第3、4列放置了棋子(不考虑顺序，下同)，第三行在第1列放置； 

            ②前两行在第1、4列放置了棋子，第三行在第3列放置； 

            ③前两行在第1、3列放置了棋子，第三行在第4列放置。

        这三种情况互不相交，且只可能有这三种情况，根据加法原理，fs应该等于这三种情况的和。写成递推式就             是：

         f(01101) = f(01100) + f(01001) ＋ f(00101);

• 根据上面的讨论思路推广之，得到引例的解决办法： 

        f(0) = 1;

        f(s) = ·f(s-2^i);

          其中s的右起第i+1位为1(其实就是在枚举s的二进制表示中的1)

代码如下：

[cpp]  view plain  copy

 print ?

1. #include<iostream>  
2. #include<cstdio>  
3. using namespace std;  
4. long long f[1<<20];  
5.   
6. int main(){  
7.     long long n;  
8.     while(cin>>n){  
9.         memset(f,0,sizeof(f));  
10.         f[0] = 1;  
11.         long long i,t;  
12.         for( i=1; i< 1<<n; i++){  
13.             for( t=i; t>0; t -= (t & -t)){  
14.                 f[i] += f[i & ~(t & -t)];  //注意理解  
15.             }  
16.         }  
17.         cout<<f[(1<<n)-1]<<endl;   
18.     }  
19. }  

 

问题2：在n*n(n≤20)的方格棋盘上放置n 个车，某些格子不能放，求使它们不能互
      相攻击的方案总数。
输入：给你一个n和m，分别表示棋盘的大小，不能放的格子总数
      接下来是m行坐标，表示不能放置的位子。
输出：符合条件的方案总数。

0表示可以放置，1表示不能放置
0 1 0
0 0 1
0 0 0
输入：
3 2 
1 2 
2 3 
输出：3
输入：
4 1
1 1 
输出：3*3*2*1 == 18
提示：
1 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0

[cpp]  view plain  copy

 print ?

1. #include<iostream>  
2. #include<cstdio>  
3. #include<algorithm>  
4. #include<cstring>  
5. using namespace std;  
6.   
7. long long f[1<<20];  
8. long long vist[22];  
9.   
10. int main(){  
11.     long long n,m;  
12.     while(cin>>n>>m){  
13.         memset(f,0,sizeof(f));  
14.         memset(vist,0,sizeof(vist));  
15.         for(int i=0;i<m;i++){  
16.             int a,b;  
17.             cin>>a>>b;  
18.             vist[a] += 1<<(b-1); //某一个位置不能放置，把这个位置压缩成整数   
19.         }  
20.         f[0] = 1;  
21.         for(int i=1;i< 1<<n; i++){  
22.             int num = 0;  
23.             for(int j=i;j>0;j -= (j & -j)) num++; //计算 i 这一个状态 1 的个数，也就是最多包涵的行数   
24.             for(int j=i;j>0;j -= (j & -j)) {  
25.                 if(!(vist[num]&(j & -j))) f[i] += f[ i& ~(j & -j)];//判断该位置是否可以放置   
26.             }  
27.         }  
28.         cout<<f[(1<<n)-1]<<endl;  
29.     }  
30. }  

问题3：给出一个n*m 的棋盘(n、m≤80,n*m≤80)，要在棋盘上放k(k≤20)个棋子，
使得任意两个棋子不相邻。求可以放置的总的方案数

[cpp]  view plain  copy

 print ?

1. #include<iostream>  
2. #include<cstdio>  
3. #include<cmath>  
4. #include<algorithm>   
5. using namespace std;  
6. int s[1<<10],c[1<<10],f[82][1<<9][21];   
7. int n,m,num,flag,val;  
8.   
9. void DFS(int ans,int pos,int flag){  ///////////////////////  
10.     if(pos>n) {   
11.         s[++num] = ans;   
12.         c[num] = flag;  
13.         return;   
14.     }  
15.     DFS(ans,pos+1,flag);  
16.     DFS(ans+(1<<pos-1),pos+2,flag+1);  
17. }  
18.   
19. int main(){  
20.     while(cin>>n>>m>>val){  
21.         if(n>m) swap(n,m); // 行列交换   
22.         num = 0;  // 状态数初始化    
23.         DFS(0,1,0); // 参数：当前状态，位置，1的个数 ，找出一行中符合条件的总数   
24.         memset(f,0,sizeof(f));  
25.         ///////////////////////////////////////////  
26.         for(int i=1;i<=num;i++) //第一行进行初始化，状态中有多少个1就初始多少   
27.             f[1][s[i]][c[i]] = 1;  
28.         for(int i=2;i<=m;i++){ //第几行   
29.             for(int j=1;j<=num;j++){ //某一行的某个状态   
30.                 for(int r=1;r<=num;r++){ //上一行的某个状态   
31.                     if(!(s[j]&s[r])){ //当前行和上一行状态不冲突   
32.                         for(int k=0;k<=val;k++){ //枚举当前一行棋子的个数   
33.                             if(k>=c[j]) f[i][s[j]][k] += f[i-1][s[r]][k-c[j]]; //借助上一行的状态枚举当前状态   
34.                         }  
35.                     }  
36.                 }  
37.             }  
38.         }  
39.         long long sum=0;  
40.         for(int i=1;i<=num;i++) // 累加最后一行符合条件的总数   
41.             sum += f[m][s[i]][val];  
42.         cout<<sum<<endl;  
43.     }  
44. }  
45. /* 
46.  
47. 由于数据缺乏，自己模拟了几组数据  
48. 输入：3 3 2  
49. 输出：23 
50.  
51. 输入： 2 2 2 
52. 输出： 2 
53.  
54. 输入：20 1 2 
55. 输出： 171 
56.  
57. */   

 

问题4： 
在n*n(n≤10)的棋盘上放k 个国王(可攻击相邻的8 个格子)，求使它们无法
互相攻击的方案数。

 

[cpp]  view plain  copy

 print ?

1. #include<iostream>   
2. #include<cmath>  
3. #include<algorithm>  
4. #include<cstring>  
5. #include<cstdio>  
6. using namespace std;  
7. long long f[11][1<<10][30];  
8. int s[1<<10],c[1<<10],num;  
9. int n,m,val;  
10.       
11. void DFS(int ans,int pos,int flag){  
12.     if(pos>n){  
13.         s[++num] = ans;  
14.         c[num] = flag;  
15.         return ;  
16.     }  
17.     DFS(ans,pos+1,flag);  
18.     DFS(ans+(1<<pos-1),pos+2,flag+1);  
19. }  
20.   
21. int main(){  
22.     while(cin>>n>>m>>val){  
23.         num = 0;  
24.         DFS(0,1,0);  
25.         memset(f,0,sizeof(f));   
26.         for(int i=1;i<=num;i++)  
27.             f[1][s[i]][c[i]]=1;  
28.         for(int i=2;i<=n;i++){  
29.             for(int j=1;j<=num;j++){ //当前行   
30.                 for(int r=1;r<=num;r++){ //上一行   
31.                     if((s[j]&s[r]) || ((s[j]>>1)&s[r]) || ((s[j]<<1)&s[r])) continue; //八个方向判断   
32.                     for(int k=0;k<=val;k++){  
33.                         if(k>=c[j]) f[i][s[j]][k] += f[i-1][s[r]][k-c[j]];  
34.                     }  
35.                 }  
36.             }  
37.         }  
38.         long long sum=0;  
39.         for(int i=1;i<=num;i++)  
40.             sum += f[n][s[i]][val];  
41.         cout<<sum<<endl;  
42.     }  
43. }  
44. /* 
45.  
46. 输入：3 3 2 
47. 输出：16 
48.  
49. 输入：2 2 1 
50. 输出：4 
51.  
52. 输入：3 3 3 
53. 输出：8 
54.  
55. 输入：9 9 2 
56. 输出：1968  
57.  
58. */   

题目5：给出一个n*m(n≤100,m≤10)的棋盘，一些格子不能放置棋子。求最多能在

棋盘上放置多少个棋子，使得每一行每一列的任两个棋子间至少有两个空格。 

[cpp]  view plain  copy

 print ?

1. #include<iostream>  
2. #include<cstdio>  
3. #include<algorithm>  
4. #include<cstring>  
5. #include<cmath>  
6. using namespace std;  
7. long long f[11][1<<10];  
8. int n,m,s[1<<10],c[1<<10];  
9. int num,ant,a[1<<10];  
10.   
11. void DFS(int ans,int pos,int flag){  
12.     if(pos>m){  
13.         s[++num] = ans;  
14.         c[num] = flag;  
15.         return ;  
16.     }  
17.     DFS(ans,pos+1,flag);  
18.     DFS(ans+(1<<pos-1),pos+3,flag+1);  
19. }  
20.   
21. int main(){  
22.     while(cin>>n>>m>>ant){  
23.         int p,q;  
24.         for(int i=0;i<ant;i++){  
25.             cin>>p>>q;  
26.             a[p] += (1<<q-1);  
27.         }  
28.         memset(f,0,sizeof(f));  
29.         num = 0;  
30.         DFS(0,1,0);  
31.       //  for(int i=1;i<=num;i++) cout<<s[i]<<" "<<c[i]<<endl;  
32.         for(int i=1;i<3 && i<=n;i++){  
33.             for(int j=1;j<=num;j++){ // i==2时，表示当前行 , i==1时表示当前行   
34.                 if(i==1){  
35.                     if(a[i]&s[j]) continue;  // 不能放置  
36.                     f[i][s[j]]=c[j];  
37.                 }  
38.                 else {  
39.                     if(a[i]&s[j]) continue;  // 不能放置  
40.                     for(int r=1;r<=num;r++){ // 不能放置并且和状态 1 不冲突  , 表示前一行的状态   
41.                         if(a[i-1]&s[r]) continue;  // 不能放置   
42.                         if((s[j]&s[r])) continue;  
43.                         f[i][s[j]] = max(f[i][s[j]],f[i-1][s[r]]+c[j]);   
44.                     }  
45.                 }  
46.             }  
47.         }  
48.         for(int i=3;i<=n;i++){  
49.             for(int j=1;j<=num;j++){//当前行   
50.                 if(s[j]&a[i]) continue;  
51.                 for(int r=1;r<=num;r++){//上一行 i-1  
52.                     if((s[r]&a[i-1]) || (s[j]&s[r])) continue;  
53.                     for(int h=1;h<=num;h++){//再上一行 i-2  
54.                         if((s[h]&a[i-3])||(s[j]&s[h])||(s[r]&s[h])) continue;  
55.                         f[i][s[j]] = max(f[i][s[j]],f[i-2][s[h]]+c[j]+c[r]);  
56.                     }  
57.                 }  
58.             }  
59.         }  
60.         long long sum = 0;  
61.         for(int i=1;i<=num;i++)   
62.             sum = max(f[n][s[i]],sum);  
63.         cout<<sum<<endl;  
64.     }  
65. }   
66. /* 
67.  
68. 输入：  
69. 3 3 3 
70. 2 1 
71. 2 2 
72. 2 3 
73. 输出：2  
74.  
75. */  

题目6:  
给出n*m(1≤n、m≤11)的方格棋盘，用1*2 的长方形骨牌不重叠地覆盖这个
棋盘，求覆盖满的方案数。

[cpp]  view plain  copy

 print ?

1. #include<iostream>  
2. #include<cstdio>   
3. #include<algorithm>  
4. #include<cstring>  
5. #include<cmath>  
6. #include<string>  
7. using namespace std;  
8. long long f[12][1<<14];  
9. int s1[1<<14],s2[1<<14],s[1<<14],ss[1<<14];  
10. int n,m,num,flag;  
11. bool vist[1<<14];  
12.   
13. void DFS(int ans1,int ans2,int pos){  
14.     if(pos>n) {  
15.         if(pos==n+1) {  
16.             s1[++num] = ans1;  
17.             s2[num] = ans2;  
18.         }  
19.         return ;  
20.     }  
21.     DFS(ans1,ans2,pos+1); // 不放   
22.     DFS(ans1+(1<<pos-1)+(1<<pos),ans2,pos+2); // 横放   
23.     DFS(ans1+(1<<pos-1),ans2+(1<<pos-1),pos+1); // 竖放   
24. }  
25.   
26. void dfs(int ans,int pos){  
27.     if(pos>n){  
28.         if(pos==n+1)  
29.             s[++flag] = ans;  
30.         return;  
31.     }  
32.     dfs(ans,pos+1);  
33.     dfs(ans+(1<<pos-1)+(1<<pos),pos+2);  
34. }  
35.   
36. int main(){  
37.     while(cin>>n>>m){  
38.         if(n==0 && m==0) break;  
39.         if(n%2 && m%2){ cout<<'0'<<endl; continue; }  
40.         if(n > m) swap(n,m);  
41.         if(n%2) swap(n,m);  
42.         if(m==1) { cout<<'1'<<endl; continue; }  
43.         num = 0; flag = 0;  
44.         DFS(0,0,1);  
45.         dfs(0,1); // 第一行所有状态搜索   
46.         memset(f,0,sizeof(f));   
47.         for(int i=1;i<=flag;i++)  
48.             f[1][s[i]] = 1;  
49.         int ant = (1<<n) - 1;  
50.         for(int i=1;i<=num;i++){ //第二行   
51.             ss[i] = s1[i];  
52.             for(int j=1;j<=flag;j++){ //第一行   
53.                 if((s2[i]&s[j])) continue;  
54.                 if((ant-s2[i])&(ant-s[j])) continue; //处理相同的 0    
55.                 f[2][s1[i]] += f[1][s[j]];  
56.             }  
57.         }  
58.         sort(ss+1,ss+num);  
59.         int ans = 0;  
60.         ss[++ans] = ss[1];  
61.         for(int i=2;i<=num;i++){  //除去相同的 ，避免重复计算   
62.             if(ss[i]!=ss[i-1]) ss[++ans] = ss[i];  
63.         }  
64.         for(int i=3;i<=m;i++){ //第三行  
65.             for(int j=1;j<=num;j++){//第 i 行状态遍历   
66.                 for(int r=1;r<=ans;r++){ // 第 i-1 行 *****相同的 s1[r]只能计算一次 WA了N久   
67.                     if(s2[j]&ss[r]) continue;  
68.                     if((ant-s2[j])&(ant-ss[r])) continue;  
69.                     f[i][s1[j]] += f[i-1][ss[r]];  
70.                 }   
71.             }  
72.         }   
73.         cout<<f[m][(1<<n)-1]<<endl;  
74.     }  
75. }