插头DP代码

#include<cstdio>
#include<cstring>
#include<iostream>
using namespace std;
const int cube=(int)1e9;
const int mod=2601;
int n,m;
struct Data_Analysis//有关高精
{
    int bit[6];//存储答案的高精数组，bit[i]中不止一个数，会存在一个很大的数
    inline void Clear()  {memset(bit,0,sizeof(bit));}
    Data_Analysis()  {Clear();}//初始化清空
    inline void Set(int t)
    {
        Clear();
        while(t)  {bit[++bit[0]]=t%cube;  t/=cube;}//类似于高精中的对10取模及做乘法，只不过变为对1e9取模做乘法
    }
    inline int &operator [](int x)  {return bit[x];}
    inline void Print()
    {
        printf("%d",bit[bit[0]]);//bit[0]可能小于0,但是此时也需要输出0,所以需要这么一步
        for(int i=bit[0]-1;i>0;i--)  printf("%d",bit[i]);//正常倒着输出
        printf("
");
    }
    inline Data_Analysis operator + (Data_Analysis b)//高精加
    {
        Data_Analysis c;  c.Clear();  c[0]=max(bit[0],b[0])+1;//两数相加的位数最多为位数大的那个+1
        for(int i=1;i<=c[0];i++)  {c[i]+=bit[i]+b[i];  c[i+1]+=c[i]/cube;  c[i]%=cube;}
        while(!c[c[0]])  c[0]--;//排除最高位的0
        return c;
    }
    inline void operator += (Data_Analysis b)  {*this=*this+b;}//*this"返回当前对象的引用 或者说返回该对象本身 还是当前对象的克隆"
    inline void operator = (int x)  {Set(x);}//最初bit[0]=0，计数用，所以在最初赋值时也直接用set，把bit[0]留出来
}Ans;
struct Hash_Sheet//有关hash
{
    Data_Analysis val[mod];//方案数
    int key[mod],size,hash[mod];//所表示的真实状态，元素个数，是hash表中第几个元素
    inline void Initialize()//初始化清空
    {
        size=0;  memset(val,0,sizeof(val));
        memset(key,-1,sizeof(key));  memset(hash,0,sizeof(hash));
    }
    inline void Newhash(int id,int v)  {hash[id]=++size;  key[size]=v;}//在hash表中添加新元素
    Data_Analysis &operator [](const int State)
    {
        for(int i=State%mod;;i=(i+1==mod)?0:i+1)//不停的通过+1的操作向后找，循环查找，直到找到，通过retrun结束for循环
        {
            if(!hash[i])  Newhash(i,State);//没有就添加新元素
            if(key[hash[i]]==State)  return val[hash[i]];//找到该状态，返回该状态下的方案数
        }
    }
}f[2];
//所有状态均为4进制（以2进制为基础，每两位看作一个整体代表4进制，利用位运算简化操作过程）
//0无插头 1左插头 2右插头
inline int Find(int State,int id)//查找该处插头种类，id代表所在格子是第几列，所以id=x时对应二进制表示中（两位一整体）第x-1个整体
{
    return (State>>((id-1)<<1))&3;//(id-1)<<1即(id-1)*2，目的是把需要被查找的位置移到第0，1位处，&3会把除最后两位之外的其他位均置0，并且不改变最后两位
}
inline void Set(int &State,int bit,int val)//修改插头类型
{
    bit=(bit-1)<<1;//由于两位一整体，直接算出当前整体的前一位在哪
    State|=3<<bit;//先置1
    State^=3<<bit;//后置0
    State|=val<<bit;//把当前位置改变为val
}
inline int Link(int State,int pos)//查找对应的另一个插头在哪
{
    int cnt=0;//标记已经历过的左右插头能否相互抵消，当相互抵消时证明找到了当前插头的对应插头
    int Delta=(Find(State,pos)==1)?1:-1;//当前是左插头，就向右找，否则向左找
    for(int i=pos;i&&i<=m+1;i+=Delta)//有可能向左，有可能向右，所以要保证1<=i<=m+1（插头编号由1到m+1）
    {
        int plug=Find(State,i);
        if(plug==1)  cnt++;
        else if(plug==2)  cnt--;
        if(cnt==0)  return i;//一一对应证明找到了相对的左/右插头
    }
    return -1;//扫了一遍没找到
}
inline void Execution(int x,int y)
{
    //((x-1)*m+y)求出是第几个格
    int now=((x-1)*m+y)&1;//now只有可能=0/1，只保留最后一位
    int last=now^1;//0^1=1 1^1=0记录连着的上一个格子，类似于滚动数组只用0/1
    int tot=f[last].size;//上一个格子共有tot种不同状态
    f[now].Initialize();//给当前格子清零
    for(int i=1;i<=tot;i++)
    {
        int State=f[last].key[i];//枚举决策上一个格子时的所有不同状态
        Data_Analysis Val=f[last].val[i];//状态所对应的方案数
        int plug1=Find(State,y),plug2=Find(State,y+1);//寻找当前决策的格子上的两个插头的种类
        if(Link(State,y)==-1||Link(State,y+1)==-1)  continue;//没有对应的插头
        if(!plug1&&!plug2)//没有插头
        {
            if(x!=n&&y!=m)  {Set(State,y,1);  Set(State,y+1,2);  f[now][State]+=Val;}//只要不是最后一个格子，就建下插头及右插头，作为1插头和2插头
        }
        else if(plug1&&!plug2)//只有一个来自左边的插头
        {
            if(x!=n)  f[now][State]+=Val;//转弯，连接一个下插头
            if(y!=m)  {Set(State,y,0);  Set(State,y+1,plug1);  f[now][State]+=Val;}//直走，向右
        }
        else if(!plug1&&plug2)//只有一个来自上面的插头
        {
            if(y!=m)  f[now][State]+=Val;//转弯，连接一个右插头
            if(x!=n)  {Set(State,y,plug2);  Set(State,y+1,0);  f[now][State]+=Val;}//直走，向下
        }
        else if(plug1==1&&plug2==1)//两个左插头，把靠里的那个左插头的右插头变为左插头，两个插头联通，置为没有
            {Set(State,Link(State,y+1),1);  Set(State,y,0);  Set(State,y+1,0);  f[now][State]+=Val;}
        else if(plug1==1&&plug2==2)//左边是左插头，右边是右插头
            {if(x==n&&y==m)  Ans+=Val;}//如果是最后一个格子，直接封口
        else if(plug1==2&&plug2==1)//左边是右插头，右边是左插头，没影响，直接判联通，置为0,对对应插头无影响
            {Set(State,y,0);  Set(State,y+1,0);  f[now][State]+=Val;}
        else if(plug1==2&&plug2==2)//两个右插头，联通置为0,靠里的左插头变右
            {Set(State,Link(State,y),2);  Set(State,y,0);  Set(State,y+1,0);  f[now][State]+=Val;}
    }
}
int main()
{
    scanf("%d%d",&n,&m);
    if(m>n)  swap(n,m);//用较小数状压
    f[0].Initialize();  f[0][0]=1;
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++)  Execution(i,j);
        if(i!=n)//行间转移
        {
            int now=(i*m)&1,tot=f[now].size;
            for(int j=1;j<=tot;j++)  f[now].key[j]<<=2;//两个一整体
        }
    }
    Ans+=Ans;  Ans.Print();
}