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=10;
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=12357;
    static const int NN=20010;
    int head[mod];       //桶指针
    int next[NN];        //记录链的信息
    LL  status[NN];      //状态
    LL  value[NN];       //状态对应的DP值
    ULL  path[NN];       //路径的状态
    int size;

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

    void insert(LL st, LL val,ULL p)
    {
        int h = st%mod;
        for(int i=head[h]; i!=-1; 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[2];

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

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

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

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

void trycover(int c,LL v,ULL p,int i,int j) //尝试对g[i,j]涂c色
{
    if( j>0 && color[1]==c && color[m+1]==c && color[m]==c )   return ;    //2*2同色
    color[0]=c&1;
    if(i+1==n && j+2==m)    //最后2格特处理
    {
        if( c==color[m] || !isunique() || samecolor() )
        {
            comb(c,j);
            hashmap[cur].insert(encode(), v, p);
        }
    }
    else if(i+1==n && j+1==m)//最后1格特处理
    {
        if( c==color[m] || !isunique() || samecolor() )
        {
            if(i<2|| c==color[m]||c==color[1])  //如果是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=0].clear();
    for(int i=0; i<(1<<m); i++ )   //产生第1行的所有情况。
    {
        color[m]=0;
        bool flag=1;
        for(int j=0,t=i; j<m; j++,t>>=1)  //判断是否冲突。
        {
            color[j]=(t&1);
            if(g[0][m-1-j]<2 && g[0][m-1-j]!=color[j])   flag=0;    //注意点
        }
        if(flag)
        {
            code[m-1]=0;
            for(int j=m-2,up=0; j>=0; j--)
                if(color[j]==color[j+1])    code[j]=code[j+1];
                else    code[j]=++up;
            hashmap[0].insert(encode(), 1, i);
        }
    }

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

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

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