UVA 10572 Black & White （状压DP）

题意：有一个n*m的矩阵，其中部分格子已经涂黑，部分涂白，要求为其他格子也上黑/白色，问有多少种涂法可以满足一下要求：

　　（1）任意2*2的子矩阵不可以同色。

　　（2）所有格子必须上色。

　　（3）只能有两个连通分量（即1黑1白）。

　　注：1<n,m<9。若能满足，顺便输出任一种涂色方法。

思路：　　

　　本来题也不难，只是刚开始写最小表示法，加上这题的难度，所以搞非常久。注：本题用最小表示法比较好。

　　大概逻辑如下：

　　　　if g[i][j]非首列且2*2子矩阵同色　　then　　非法状态;

　　　　if 上格连通分量不会丢失.　　then　　合格状态;

　　然后对矩阵最后的两个格子特判如下（合法状态指的是对当前格子合法）：

　　1)倒数第2格子的判断：

　　　　（1）if g[i][j]与上格同色　　then　　合法状态；

　　　　（2） if 上格的连通分量编号在轮廓线上并不是唯一　　then　　合法状态；

　　　　（3） if 轮廓线上所有格子颜色相同　　then　　合法状态；

　　2)倒数第1格子的判断：

　　　　（1）if 先尝试上面3种情况，若合法，再继续。

　　　　（2）if n=2 or 最后一个格子与上/左格（任一个以上都行）连通　　then　　合法状态；

　　当扫完所有格子后，将所有合法中连通分量最多为2个的都是符合要求的。路径记录只需要用一个64位整型来记录即可，较简单。

 #include <bits/stdc++.h>
 #include <iostream>
 #include <cstdio>
 #include <cstring>
 #define pii pair<int,int>
 #define INF 0x3f3f3f3f
 #define LL long long
 #define ULL unsigned long long
 using namespace std;
 const int N=;
 int g[N][N], code[N],color[N], cur, n, m;
 int num[N];         //用于最小表示法
 char str[N][N];     //用于路径输出
 struct Hash_Map
 {
     static const int mod=;
     static const int NN=;
     int head[mod];       //桶指针
     int next[NN];        //记录链的信息
     LL  status[NN];      //状态
     LL  value[NN];       //状态对应的DP值
     ULL  path[NN];       //路径的状态
     int size;

     void clear()
     {
         memset(head, -, sizeof(head));
         size = ;
     }

     void insert(LL st, LL val,ULL p)
     {
         int h = st%mod;
         for(int i=head[h]; i!=-; i=next[i])
         {
             if(status[i] == st)
             {
                 value[i] += val;
                 path[i] = p;    //任一路径
                 return ;
             }
         }
         status[size]= st;
         value[size] = val;
         path[size] = p;
         next[size] = head[h] ;
         head[h] = size++;
     }
 }hashmap[];

 LL encode()         //编码
 {
     memset(num,-,sizeof(num));
     LL s=;
     for(int i=m-,cnt=; i>=; i--)
     {
         if(num[code[i]]<)  num[code[i]]=cnt++;
         s<<=;
         s+=(num[code[i]]&)+color[i]*; //最高位为颜色，低3位为轮廓线
     }
     s<<=;
     s+=color[m];  //color[m]放在最低位,方便处理。
     return s;
 }

 void decode(LL s)      //解码：1个颜色位+3个状态位表示一个格子状态
 {
     color[m+]=(s&);s>>=;
     for(int i=; i<=m; i++)  //解码到code[1~m]上面,就不用移动。
     {
         code[i]=(s&);    s>>=;
         color[i]=(s&);   s>>=;
     }
 }

 inline bool isunique()  //判断上格子的连通分量是否唯一。
 {
     for(int i=; i<m; i++)    if( code[i]==code[m] )    return false;
     return true;
 }
 inline bool samecolor() //轮廓线上除了color[m]外，所有格子是否同色
 {
     for(int i=; i<m; i++)    if(color[i]!=color[i-])    return false;
     return true;
 }

 void comb(int c,int j)  //合并连通分量
 {
     if( c==color[m] )    code[]=code[m]; //与上同色
     else                code[]=;
     if(j> && c==color[] )              //与左同色
     {
         int t=code[];
         for(int i=; i<m; i++)    if( code[i]==t )    code[i]=code[];
     }
 }

 void trycover(int c,LL v,ULL p,int i,int j) //尝试对g[i,j]涂c色
 {
     if( j> && color[]==c && color[m+]==c && color[m]==c )   return ;    //2*2同色
     color[]=c&;
     if(i+==n && j+==m)    //最后2格特处理
     {
         if( c==color[m] || !isunique() || samecolor() )
         {
             comb(c,j);
             hashmap[cur].insert(encode(), v, p);
         }
     }
     else if(i+==n && j+==m)//最后1格特处理
     {
         if( c==color[m] || !isunique() || samecolor() )
         {
             if(i<|| c==color[m]||c==color[])  //如果是m=2的矩阵，需要特别注意最后两个格子。
             {
                 comb(c,j);
                 hashmap[cur].insert(encode(), v, p);
             }
         }
     }
     else
     {
         if( c!=color[m] && isunique() ) return ;        //连通分量消失
         comb(c,j);
         hashmap[cur].insert(encode(), v, p);
     }
 }

 void cal()
 {
     hashmap[cur=].clear();
     for(int i=; i<(<<m); i++ )   //产生第1行的所有情况。
     {
         color[m]=;
         bool flag=;
         for(int j=,t=i; j<m; j++,t>>=)  //判断是否冲突。
         {
             color[j]=(t&);
             if(g[][m--j]< && g[][m--j]!=color[j])   flag=;    //注意点
         }
         if(flag)
         {
             code[m-]=;
             for(int j=m-,up=; j>=; j--)
                 if(color[j]==color[j+])    code[j]=code[j+];
                 else    code[j]=++up;
             hashmap[].insert(encode(), , i);
         }
     }

     for(int i=; i<n; i++)  //穷举剩下所有格子。
     {
         for(int j=; j<m; j++)
         {
             cur^=;
             hashmap[cur].clear();
             for(int k=; k<hashmap[cur^].size; k++)
             {
                 LL s=hashmap[cur^].status[k];
                 LL v=hashmap[cur^].value[k];
                 ULL p=hashmap[cur^].path[k];
                 decode(s);
                 p<<=;
                 if( g[i][j]== )
                 {
                     trycover(,v,p+,i,j);
                     trycover(,v,p+,i,j);
                 }
                 else    trycover(g[i][j],v,p+g[i][j],i,j);
             }
         }
     }
 }

 void print()    //答案及路径输出。
 {
     int ans=;ULL mapp=;
     for(int i=; i<hashmap[cur].size; i++)
     {
         int big=;
         decode(hashmap[cur].status[i]);
         for(int y=; y<=m; y++)    big=max(big, code[y]);   //求最大编号
         if(big<=)
         {
             mapp=hashmap[cur].path[i];
             ans+=hashmap[cur].value[i];
         }
     }
     printf("%d\n", ans);
     if(ans)
     {
         memset(str,'\0',sizeof(str));
         for(int i=n-; i>=; i--)
         {
             for(int j=m-; j>=; j--)
             {
                 if(mapp&)  str[i][j]='#';
                 else        str[i][j]='o';
                 mapp>>=;
             }
         }
         for(int i=; i<n; i++)    printf("%s\n",str[i]);
     }
 }

 int main()
 {
     freopen("input.txt", "r", stdin);
     int t;cin>>t;
     while(t--)
     {
         memset(g,,sizeof(g));
         scanf("%d%d", &n,&m);
         for(int i=; i<n; i++)
         {
             for(int j=; j<m; j++)
             {
                 char c=getchar();
                 if(c=='#')          g[i][j]=;          //黑色
                 else if(c=='o')     g[i][j]=;
                 else if(c=='.')     g[i][j]=;
                 else j--;
             }
         }
         cal();print();printf("\n");
     }
     return ;
 }

AC代码