POJ-2411 Mondriaan's Dream 状态压缩DP

　　题目链接：http://poj.org/problem?id=2411

　　啪啦啪啦敲了80+行，1A。结果看Discuss，别人20行就解决了= =！，果然是我想复杂了。我的状态压缩效果不是很好，貌似很挫，因为状态考虑得太多了，没有类化，用了2bit的空间来表示每个格子的状态即当前放的是横向01，没放00，竖向11。而且状态转移的时候考虑的是从后面来判断前面的状态是否可行，这样的话每行就多记录了些状态（需要记录格子为空的情况）。

　　其实简单的做法就是从前一状态推向后一状态，用0表示当前格子放置了，1表示当前格子放置的是竖向的，而且是向下凸出的。状态转移方程：f[k][i]=sum{f[k-1][j]}(i和j状态需匹配)，这样的话转移的状态就少了很多，而且操作很方便。一般的做法就是先用DFS搜索出status，然后再来判断匹配。其实这里有个很好的技巧，可以避免先用DFS来找出status。我是从Discuss那份20行代码里学的，从状态的每个位开始，然后遍历每个状态，根据当前状态来确定后继状态，知道遍历完，具体看下面：

算法核心：  //摘自：http://www.cppblog.com/kill-myself/
      利用二进制状态压缩保存后n个格子是否放置，利用位运算可以更高效率地状态转移（在本程序中，第i位二进制保存：后n个格子中，在第i列的格子是否已填）。由于可以由前一个格子状态转移，利用滚动数组节省空间。
具体算法：
      1、由于每个格子都要填满，所以穷举每个格子。
      2、每个格子的状态可以由前一个格子的状态转移得到
                a,如果前一个格子某状态中当前格子已填，直接加在当前格子的相应的状态中。
                b,如果前一个格子某状态中当前格子未填，加在竖放的状态中。
                c,如果前一个格子某状态中当前格子未填，下一个格子未放，且不是最后一列，加在横放的状态中

　　代码如下：

 1 #include<cstdio>

 2 #include<string.h>

 3 long long f[2][4100],a,b,n,m,k,j,p;

 4 int main(){

 5    while(scanf("%d%d",&n,&m),memset(f,0,sizeof(f)),f[0][0]=p=1,a=n>m?n:m,b=n+m-a){

 6       while(a--)

 7        for(j=0;++j<=b;memset(f[p=1-p],0,sizeof(f[p])))

 8            for(k=(1<<b);--k+1;)

 9               if(k&1<<j-1)

10                  f[p][k&~(1<<j-1)]+=f[1-p][k];

11               else{

12                    f[p][k|1<<j-1]+=f[1-p][k];

13                    if(j<b&&!(k&1<<j))

14                       f[p][k|1<<j]+=f[1-p][k];

15               }

16       printf("%lld\n",f[1-p][0]);

17    }

18 }

     Orz一下...........

　　顺便说一下，本题还可用矩阵乘法来做，对于亿量级数据，矩阵+二分可以秒杀。基本方法就是转化成图论来做，找经过n条边的回路。可参考：Matrix67<十个利用矩阵乘法解决的经典题目>

 我的搓代码：

 1 //STATUS:C++_AC_1047MS_3592KB

 2 #include<stdio.h>

 3 #include<stdlib.h>

 4 #include<string.h>

 5 #include<math.h>

 6 #include<iostream>

 7 #include<string>

 8 #include<algorithm>

 9 #include<vector>

10 #include<queue>

11 #include<stack>

12 #include<map>

13 using namespace std;

14 #define LL __int64

15 #define pii pair<int,int>

16 #define Max(a,b) ((a)>(b)?(a):(b))

17 #define Min(a,b) ((a)<(b)?(a):(b))

18 #define mem(a,b) memset(a,b,sizeof(a))

19 #define lson l,mid,rt<<1

20 #define rson mid+1,r,rt<<1|1

21 const int N=14010,INF=0x3f3f3f3f,MOD=1999997;

22 const LL LLNF=0x3f3f3f3f3f3f3f3fLL;

23 

24 int sta[N],q[N][90],cou[N];

25 LL f[12][N];

26 int n,m,stacou;

27 

28 void dfs(int cur,int a,int one)

29 {

30     if(cur==m){

31         if(one)f[0][stacou]=1;

32         sta[stacou++]=a;

33         return;

34     }

35     dfs( cur+1,a,one&one);

36     dfs( cur+1,a|(1<<(cur<<1)),0 );

37     if(cur+2<=m)dfs( cur+2,a|(15<<(cur<<1)),one&one );

38     return;

39 }

40 

41 void match()

42 {

43     int i,j,p,ok;

44     for(i=0;i<stacou;i++){

45         for(j=0;j<stacou;j++){

46             for(p=0,ok=1;p<m;p++){

47                 if( (sta[i]&(1<<(p<<1)))==0 && (sta[j]&(1<<(p<<1)))!=0 )continue;

48                 else if( (sta[i]&(3<<(p<<1)))==(1<<(p<<1))

49                    && (sta[j]&(1<<(p<<1)))==0 )continue;

50                 else if( (sta[i]&(3<<(p<<1)))==(3<<(p<<1))

51                     && sta[j]&(3<<(p<<1)) )continue;

52                 else {ok=0;break;}

53             }

54             if(ok)q[i][cou[i]++]=j;

55         }

56     }

57 }

58 

59 int main()

60 {

61  //   freopen("in.txt","r",stdin);

62     int k,i,j,ok;

63     LL ans;

64     while(~scanf("%d%d",&n,&m) && (n||m))

65     {

66         if((n*m)&1){printf("0\n");continue;}

67         if(m>n)n^=m^=n^=m;

68         ans=0;

69         mem(f,0);

70         mem(cou,0);

71         stacou=0;

72         dfs(0,0,1);

73         match();

74         for(k=1;k<n;k++){

75             for(i=0;i<stacou;i++){

76                 for(j=0;j<cou[i];j++)

77                     f[k][i]+=f[k-1][q[i][j]];

78             }

79         }

80         k--;

81         for(i=0;i<stacou;i++){

82             for(j=0,ok=1;j<m;j++){

83                 if( (sta[i]&(1<<(j<<1)))==0){ok=0;break;};

84             }

85             if(ok)ans+=f[k][i];

86         }

87 

88         printf("%I64d\n",ans);

89     }

90     return 0;

91 }