【Ural1519】Formula 1 插头DP模板

原题走这里

插头DP，说白了就是一类极其要命极其复杂的状压DP
通常和连通性，环，生成树之类的东西有关
以轮廓线上的状态为DP的状态，逐格递推
以上废话请忽略……

我们先以HDU1693 Eat the Trees 作为引入，这道题是多回路，因此只需用0/1记录轮廓线上是否有回路通过。
轮廓线……就是横贯方格的一条……线，由m+1段组成，如下图：

图中深蓝色的就是轮廓线，此时轮廓线的“转折点”位于第五行第四格的右侧，轮廓线上的第1,2,3,5,6,7段有回路通过，因此该段轮廓线的状态就是(5,4,1110111)。
这时候DP的状态就可以确定为D[i][j][S]，意为当前轮廓线的状态为(i,j,S)时轮廓线以上用多回路完全覆盖的方案数。
然后转移一波就可以了，前两位其实可以滚动数组掉。

不过，本题需要的是单回路覆盖，需要确保最终只有一个连通块，于是我们还有记录下轮廓线各个线段所属的连通块，如上图，此时的连通性可以记录为（1220133）。
然而，一个很神的性质告诉我们，我们可以用括号序列来记录连通性，因为同一连通块只会越过轮廓线两次，因此同一连通块可以用一对括号来表示。此外，我们可以保证，两个连通块的两对括号不会交错，那可是极好的.jpg。
于是上图的连通性可以记录为 (()#)()，其中#代表没有回路通过。
然后可以用四进制来表示’(‘，’)’，’#’三种状态，转移一波即可。

此外，在单回路问题中，为了防止产生多个回路，有这一规律：除非是在最后一格，“()”不可转移到“##”，因为只有这一转移能产生环。

代码如下：

#include <bits/stdc++.h>
#define LL unsigned long long
using namespace std;
int n,m,s,H[41900];
map<int,int> IH;
LL d[2][41900];
char ch[13][13];
void getHash(int k,int x,int y)
{
    if(y<0||y>m-k+1)return;
    if(k==m+1)IH[x]=s,H[s++]=x;
    getHash(k+1,x<<2,y);
    getHash(k+1,x<<2|2,y-1);
    getHash(k+1,x<<2|3,y+1);
}
LL DP()
{
    int I,J;
    for(I=n;I;I--)
    {
        for(J=m-1;J>=0;J--)
        {
            if(ch[I][J]=='.')goto label;
        }
    }
label:;
    d[1][0]=1;
    for(int i=1,cur=1;i<=n;i++,cur^=1)
    {
        for(int j=0;j<m;j++,cur^=1)
        {
            memset(d[cur^1],0,sizeof(d[cur^1]));
            for(int k=0;k<s;k++)
            {
                long long temp=d[cur][k];
                if(!temp)continue;
                int t=H[k],x=t>>(j<<1)&3,y=t>>((j+1)<<1)&3;
                if(ch[i][j]=='.')
                {
                    if(x+y==3||x+y==2)
                    {
                        d[cur^1][k]+=temp;
                        d[cur^1][IH[t^((x|y)<<(j<<1))^((x|y)<<((j+1)<<1))]]+=temp;
                    }   
                    if((x==3&&y==2)||(x==2&&y==3&&i==I&&j==J)) 
                    {
                        d[cur^1][IH[t^(x<<(j<<1))^(y<<((j+1)<<1))]]+=temp;
                    }
                    if((x|y)==0)
                    {
                        d[cur^1][IH[t^(2<<(j<<1))^(3<<((j+1)<<1))]]+=temp;
                    }
                    if(x==2&&y==2)
                    {
                        for(int ii=j+2,jj=0;ii<=m;ii++)
                        {
                            if((t>>(ii<<1)&3)==2)jj++;
                            if((t>>(ii<<1)&3)==3)jj--;
                            if(jj<0)
                            {
                                d[cur^1][IH[t^(2<<(j<<1))^(2<<((j+1)<<1))^(1<<(ii<<1))]]+=temp;
                                break;
                            }   
                        } 
                    }
                    if(x==3&&y==3)
                    {
                        for(int ii=j-1,jj=0;ii>=0;ii--)
                        {
                            if((t>>(ii<<1)&3)==3)jj++;
                            if((t>>(ii<<1)&3)==2)jj--;
                            if(jj<0)
                            {
                                d[cur^1][IH[t^(3<<(j<<1))^(3<<((j+1)<<1))^(1<<(ii<<1))]]+=temp;
                                break;
                            }   
                        } 
                    }
                }
                else
                {
                    if((x|y)==0)
                    {
                        d[cur^1][k]+=temp;
                    }                       
                } 
            }
            if(i==I&&j==J)return d[cur^1][0];
        }
        memset(d[cur^1],0,sizeof(d[cur^1]));
        for(int j=0;H[j]<(1<<(m<<1));j++)
        {
            d[cur^1][IH[H[j]<<2]]=d[cur][j];
        }
    }
}
int main() {
    cin>>n>>m;
    for(int i=1;i<=n;i++)
    {
        scanf("%s",ch[i]);
    }
    getHash(0,0,0);
    cout<<DP()<<endl;;
    return 0;
}