HDU1693 Eat the Trees(插头dp)

题目链接：hdu1693

题目大意：

给你一个N*M的矩阵,矩阵中有好格子和坏格子,坏格子不能走,问你能找出多少种方法在这个矩阵中画规则的圈(可以有多个圈).

输入:首先是一个T(1<=T<=10),表示实例个数.每个实例第一行是N和M,然后是一个由0和1组成的N*M矩阵,其中0表示坏格子,1表示好格.

输出:以 Case 1: There are 3 ways to eat the trees.这种形式输出结果.保证结果不超过int的上限.

分析:此题就是URAL1519的变形,（可以先参考ural1519的题解）

不过这题可以允许有多个圈,那么当一个格子合并两个相同连通分量的插头时就可以允许这个格子不是最后一个可行格子,可以是任意的哪个可行格子.

最后计算可行状态集合时,依然用sum=0去加上当前hashmap中剩余的所有状态的出现次数即可.将URAL1519的代码略做修改即可AC.

#include<cstring>
#include<cstdio>
#include<algorithm>
using namespace std;
const int STATE=1000000+10;//逐格递推每次最多能生成的状态总数,为什么100W能装下,实例测试如果装不下hasnmap就会越界报错
const int HASH = 30007;//1<<15=32768
const int MAXD=15;
int N,M;
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]+=num;
                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
{
    for(int i=M; i>=0; i--)
    {
        code[i]=st&7;//7 111  连通的插头标记相同的数字  最多可以有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];
    }
    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++)//这里的cur是旧状态
    {
        long long st=hm[cur].state[k];
        long long num = hm[cur].f[k];
        int code[MAXD];
        decode(code,st);
        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(left==up)//如果是同一对插头的话
            {
            	/*if(i==ex&&j==ey)//只能最后一个好格
                {
                	sum +=num;//总数增加
					code[j-1]=code[j]=0;//下和右均没有插头
					if(j==M)shift(code);//j为当前行最后一列,需要右移一位
					hm[1-cur].push( encode(code),num );
                }*/
                //可以不是最后一个 因为是多个回路
                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)下面是个好格
            {
                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是最后一列的情况 因为最后一列的格子，没有上和左插头，只有下插头的话这个点不会被连通
                int max_c=1;//表示当前扫描到的最大插头编号
                for(int l=0; l<=M; l++)
                    if(max_c<code[l])
                        max_c = code[l];
                code[j-1]=code[j]=max_c+1;//新增一对插头
                hm[1-cur].push( encode(code),num );
            }
        }
    }
}
void init()
{
    memset(mp,0,sizeof(mp));
    for(int i=1; i<=N; i++)
    {
        for(int j=1; j<=M; j++)
        {
			scanf("%d",&mp[i][j]);
        }
    }
}
long long  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++)
      sum+=hm[cur].f[i];

    return sum;
}
int main()
{
	int cas;
	scanf("%d",&cas);
    for(int i=1;i<=cas;i++)
    {
    	scanf("%d%d",&N,&M);
        init();
        solve();
        printf("Case %d: There are %lld ways to eat the trees.\n",i,solve());
    }
    return 0;
}