URAL1519 Formula 1（插头dp的基础题 ——详细解释）

题目可以到vjudge上找来做，原网站注册比较麻烦。

题意：

给你一个n*m的矩阵,矩阵中有一些格子是坏的,现在要你在矩阵中画一个环,这个环要经过矩阵中所有好的格子一次,问你有多少种画法.



分析:典型的插头dp问题,详见cdq的论文<<基于连通性状态压缩的动态规划问题>>,这里我用的一般解法做的,一般解法速度没有特殊括号表示法快,但是通用性很好.
思路主要注意好状态的转移即可;
首先判断这个这个点是好是坏，坏的话对上左均没插头的状态进行转移；
如果是好的话，分为三种情况：
第一：上左均有插头。如果上左的抽头不是一对连通的话，需要将其清0，并且将另外两个连在一起。
如果是一对的话，那么只可能是最后一个好格子。（如果不是最后一个格子，是不成立的，可以画个图，找找反例）
第二：上左中只有一个有插头，那么就判断这个格子的右格子是否是好格子，好的话将其连到右格；同理判断下格，如果下格是好的话将其连到下格。
第三：如果上左均没有插头，那么他只有下右均是好格且将两个连通。

AC代码:328ms
#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)//如果是同一对插头的话
cf93

{
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 );
}
}
}
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()
{
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++)
//sum+=hm[cur].f[i];
printf("%I64d\n",sum);
}
int main()
{
while(scanf("%d%d",&N,&M)==2&&N&&M)
{
getchar();
init();
if(ex==0)//全是坏格子
{
printf("0\n");
continue;
}
solve();
}
return 0;
}