HDU 4285

HDU 4285 circuits

给你一个N*M的矩阵,矩阵有好格子和坏格子,要求你求一共有多少种情况使得K条回路包括了所有的好格子,但是回路不能嵌套.

输入:首先是一个T,表示输入实例个数.对于每个实例,第一行是N,M和K (2 <= N, M <= 12),然后是一个字符矩阵,  .  表示好格子,  *  表示坏格子.

输出:ans%1000000007

分析:依然是插头DP,只需要考虑当前格子的插头轮廓线状态集合.

当插头状态为112233,时,1和1,2和2,3和3可以合并,且每一个合并都会使得我们得到了一个满足要求的圈.

假设插头状态为:1221,那么属于连通分量2的插头不能和2合并形成一个圈,因为如果合并了,必然会嵌套,2只能和别的连通分量的插头合并.

但是如果状态是123321,此时3可以和3合并,因为如果右边的1和右边2合并变成了1,那么新状态是1133,此时3不就可以和3合并了.

相同连通分量合并的条件是:这两个插头的左边和右边对应各连通分量的插头数是偶数.

在左右括号相遇的时候判断有多少组括号包含了这组括号。

如果是奇数的话，就跳过这个状态。

证明如下：

     在外面(左边和右边)的括号想要合并，且不包含到当前括号，必须一次合并偶数个。

      如果外面有偶数个括号，其实后面未必合法，但是非法的时候一定是奇数个。因为合法的合并都是一次性合并偶数个。。。。

当生成的圈数已经到K,但是还有可行格子没走完或还有插头没消除的话,那么就是非法的状态.

另外如果单纯用S表示插头的状态,而没有圈的个数的话,是不知道还该不该继续形成下一个圈的.比如1221这个状态有可能之前没有圈,有可能之前已经产生了1个或k个圈,然后到此时的插头状态是1221,所以需要再S中用前6位二进制位(因为最多有12*12/4=36个圈)来表示该状态有几个圈.

AC代码: 12609MS

#include<cstring>
#include<cstdio>
#include<algorithm>
using namespace std;
const int STATE=1000000+10;
const int HASH = 30007;
const int MAXD=15;
const int MOD=1000000007;
int c;//表示当前圈数
int N,M,max_c;
int ex,ey;//最后一个好格的坐标
int cur;
int mp[MAXD][MAXD];
int code[MAXD];
long long sum;//记录最终的最大值
struct HASHMAP
{
    int size,head[HASH],next[STATE];//next[i]=j表示第i个状态后面链接着第j个状态
    long long state[STATE];//state[i]=S表第i个状态是S
    long long f[STATE];//f[i]=x表第i个状态有x种情况
    void init()
    {
        memset(head,-1,sizeof(head));
        size=0;
    }
    void push(long long st, long long num)
    {
        long long h = st%HASH;
        int i;
        for(i=head[h]; i!=-1; i=next[i])
        {
            if(state[i]==st)
            {
                f[i]=(f[i]+num)%MOD;
                return ;
            }
        }
        next[size]=head[h];
        head[h]=size;
        f[size]=num;
        state[size]=st;
        size++;
    }
}hm[2];
void decode(int *code,long long st)//st->code
{
    c = st&63;//提取该状态标记的圈数
    st>>=6;
    for(int i=M; i>=0; i--)
    {
        code[i]=st&7;
        st>>=3;
    }
}
long long encode(int *code)//code->st
{
    int ch[MAXD];
    memset(ch,-1,sizeof(ch));
    ch[0]=0;
    int cnt=1;
    long long st=0;
    for(int i=0; i<=M; i++)
    {
        if( ch[code[i]]==-1 ) ch[code[i]]= cnt++;
        code[i]=ch[code[i]];
        st<<=3;
        st|=code[i];
    }
    st<<=6;
    st|=c;
    return st;
}
void shift(int *code)//处理完了一行的最后一列,将code整体右移一位,首位添0
{
    for(int i=M; i>=1; i--)
        code[i]=code[i-1];
    code[0]=0;
}
void dpblock(int i,int j)//坏格
{
    for(int k=0; k<hm[cur].size; k++)
    {
        long long st=hm[cur].state[k];
        int code[MAXD];
        decode(code,st);
        int left=code[j-1] ,up=code[j];
        if(left==0&&up==0)//全无插头时,才能生成新状态
        {
            if(j==M)//j为当前行最后一列,需要右移一位
                shift(code);
            hm[1-cur].push(encode(code),hm[cur].f[k]);
        }
    }
}
void dpblank(int i,int j)//好格
{
    for(int k=0; k<hm[cur].size; k++)
    {
        long long st=hm[cur].state[k];
        long long num = hm[cur].f[k];
        int code[MAXD],code1[MAXD];
        decode(code,st);
        memcpy(code1,code,sizeof(code));
        int left=code[j-1] ,up=code[j];
        if(left>0&&up>0)//都有插头
        {
            if(left!=up)//合并两个连通分量
            {
                code[j-1]=code[j]=0;
                for(int l=0; l<=M; l++)
                    if(code[l]==up)
                        code[l]=left;
                if(j==M)shift(code);//j为当前行最后一列,需要右移一位
                hm[1-cur].push( encode(code),num );
            }
            else//最后一个好格
            {
                if(c>=max_c)
                    continue;
                int t=0;
                for(int l=0;l<j-1;l++)
                    if(code[l])
                        t++;
                if(t%2==1)
                    continue;//左边有奇数个插头则不能合并
                c++;
                code[j-1]=code[j]=0;
                if(j==M)shift(code);//j为当前行最后一列,需要右移一位
                hm[1-cur].push( encode(code),num );
            }
        }
        else if(left>0||up>0)//其中一个有插头另一个没有
        {
            if(mp[i][j+1]==1)//(i,j)右边是个好格
            {
                code[j-1]=0;
                code[j]=left+up;
                if(j==M)shift(code);//j为当前行最后一列,需要右移一位
                hm[1-cur].push( encode(code),num );
            }
            if(mp[i+1][j]==1)//(i,j)下面是个好格
            {
                memcpy(code,code1,sizeof(code));
                code[j-1]=left+up;
                code[j]=0;
                if(j==M)shift(code);//j为当前行最后一列,需要右移一位
                hm[1-cur].push( encode(code),num );
            }
        }
        else//两个都没插头
        {
            if(mp[i][j+1]==1&&mp[i+1][j]==1)//(i,j)格的右边和下边是可行格,才可以新生成一个连通分量
            {//这里不会出现j是最后一列的情况
                code[j-1]=code[j]=13;
                hm[1-cur].push( encode(code),num );
            }
        }
    }
}
void init()
{
    ex=ey=0;
    memset(mp,0,sizeof(mp));
    for(int i=1; i<=N; i++)
    {
        for(int j=1; j<=M; j++)
        {
            char a;
            scanf("%c",&a);
            if(a=='.')
            {
                mp[i][j]=1;//好格为1
                ex=i;
                ey=j;
            }
        }
        getchar();//读'\n'
    }
}
void solve()
{
    sum=0;
    cur=0;
    hm[cur].init();
    hm[cur].push(0,1);
    for(int i=1; i<=N; i++)
        for(int j=1; j<=M; j++)
        {
            hm[1-cur].init();
            if(mp[i][j])
                dpblank(i,j);
            else
                dpblock(i,j);
            cur=1-cur;
        }
    for(int i=0;i<hm[cur].size;i++)
    {
        long long st = hm[cur].state[i];
        decode(code,st);
        if(c==max_c)//到达了要求的圈数才是合法状态
            sum =(sum + hm[cur].f[i])%MOD;
    }
    printf("%I64d\n",sum);
}
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d%d",&N,&M,&max_c);
        getchar();
        init();
        if(max_c==0)
        {
            printf("1\n");
            continue;
        }
        else if(ex==0)//全是坏格子
        {
            printf("0\n");
            continue;
        }
        solve();
    }
    return 0;
}