【Learning】插头DP
简介
插头DP（轮廓线DP）是用来解决网格图回路问题的一种算法。
插头DP解决的经典问题就是统计经过所有格子的哈密顿回路条数，某些格子有障碍。
如果问题稍微进阶一点的话，不一定要求路径是回路、路径带权等等情况都可能出现。
它的时间复杂度比较高，但是已经属于比较高效的算法了。
基本概念
首先看经典问题：统计一个带障碍的\(n*m\)网格中\((n,m\le 12)\)，经过所有格子的哈密顿回路的条数。
插头DP的状态围绕轮廓线进行转移。
我们的状态是\(f(i,j,state)\)，表示\((i,j)\)格子转移完成后、轮廓线状态为\(state\)时的情况数。
轮廓线的形状相对于每一个\((i,j)\)是确定的。\((i,j)\)转移之前到转移之后，轮廓线的形状、变化如图所示：
即转移的格子\((i,j)\)原来是轮廓线上的一个凸出点，转移后把轮廓线“从左上往右下拉”，使得\((i,j)\)变成一个凹格。
轮廓线的长度为\(m+1\)，我们需要记录轮廓线的每一条边的上方（对于轮廓线中打竖的那条边，则是左方），是否有边作为接口，即是否有插头。这个信息，我们存在\(state\)中。
轮廓线所体现的，一是轮廓线上的插头状态，告诉你每一个地方是否应该用一条路径“接上”；二是所有路径的连通性：显然，路径是两两相连，两两成对的，我们分组标号来记录。下面用几幅图来表达一下轮廓线的记录方式：
括号的每个数代表对应轮廓线边的状态，"0"表示没有路径连接，其他数表示一对路径，每对路径的标号一样。
考虑到标号的大小没有保证，会导致状态的储存十分困难。
我们另寻它法：注意到每对路径在轮廓线上的接口不会相交，即不会出现\((...,x,...,y,...x,...y,...)\)的这种诡异情况。所以我们可以用括号序列来表示路径信息。还是上述三个例子：
这样一来，状态\(state\)可以看做一个\(m+1\)位的3进制数：0表示无接口，1表示一对路径的左端，2表示一对路径的右端。
转移
\(f(i,j,state)\)的转移来源，是\(f(i,j-1,state')\)，但这样不好考虑和枚举。我们用\(f(i,j,state)\)，转移到\(f(i,j+1,state')\)。
我们将\(f(i,j,\sum state)\)转移到\(f(i,j+1,\sum state')\)称作大转移。
显然，我们只需要关注轮廓线上唯一变动的两条边：我们把轮廓线从左上拉到右下，这两条边的状态会更改，更改后是什么呢？取决于新的一格内路径怎么走：
我们现在关注转移的位点：
大转移的整体步骤是：枚举每一个状态\(state\)，得到\(p_a\)和\(p_b\)，根据\(p_a\)和\(p_b\)的取值，枚举\((i,j)\)的路径走法，对于选择的\((i,j)\)的走法，由\(state\)修改\(p_a\)和\(p_b\)分别变成\(p_a'\)和\(p_b'\)而得到新状态\(state'\)，执行\(f(i,j+1,state')+=f(i,j,state)\)。
根据\(p_a,p_b\)枚举走法分三大类情况：
（1）\(p_a=0\;,p_b=0\)：
这表明\((i,j)\)的左方和上方没有路径连接，则当前格只能选取1号走法。
令\(p_a'=1,p_b'=2\)得到新状态。（转移前提：\(且i<n且j<m\)，否则将出现连向网格边界的路径）
（2）\(p_a\)和\(p_b\)恰好有一个是0：
这表明\((i,j)\)的左方或者上方有一条路径连接。
由于这种走法只是将连进来的路径延长，所以这条路径在原轮廓线和新轮廓线上的性质是一样的，括号表示相同，其值也相同。
令\(p_a'=p_a+p_b,\;p_b'=0\)代表3号（\(p_a\neq0\)）或5号（\(p_b\neq0\)）走法。（转移前提：\(i<n\)）
令\(p_a'=0,\;p_b'=p_a+p_b\)代表2号（\(p_a\neq0\)）或4号（\(p_b\neq 0\)）走法。（转移前提：\(j<m\)）
（3）\(p_a\)和\(p_b\)皆不为0：
这表明\((i,j)\)的左方和上方都有路径连接，所以\((i,j)\)能填的只有6号走法，令\(p_a'=0,\;p_b'=0\)。可是我们将两条路径连接起来后，其他位置的状态也需要改变，因为括号序列发生了变动。
\(p_a=1,\;p_b=1\)：两条左端路径此刻相连，对于\(b\)对应的右端路径位置\(c\)，应该令\(p_c'=1\)，此时\(c\)和\(a\)对应的右端路径\(d\)是一对路径。
\(p_a=2,\;p_b=2\)：两条右端路径此刻相连，同上，对于\(a\)的左端路径位置\(c\)，令\(p_c'=2\)。
以上寻找对应括号路径，用括号序列配对的方式实现，复杂度\(\mathcal O(m)\)
\(p_a=1\;,p_b=2\)：一条回路此时形成。注意！这个转移只能在最后一个非障碍的位置发生，在其他任意位置连成回路都是不合法的方案。而且，答案就是被这种方式转移的量之和。这种情况我们不需要转移了，你可以姑且理解为这已经是最后一步大转移；但是对于进阶问题，如回路不一定要经过所有点，则是因为这种转移不应该被后续过程所利用（因为路径已经形成），并且答案统计可以在任意位置进行。
\(p_a=2,\;p_b=1\)：相当于从中间拼接两条路径，这种情况最舒服，因为其他位置都不会有任何变化。
转移种类较多，但是写起来其实是很好实现的。
实现
你可以将\(f(i,j,state)\)设成一个数组，但是这样非常不便，且大转移时要枚举所有状态，非常的缓慢，而在实际中，许多状态是不合法的。
我们用两个哈希表\(s_0,s_1\)来分别模拟\(f(i,j)\)和\(f(i,j+1)\)：所有有效的\(f(i,j,state)\)存在\(s_0\)中，大转移开始前，我们可以从\(s_0\)里提取所有有效状态，逐一转移至\(s_1\)中，也就是有效的\(f(i,j+1,state)\)。下一步大转移开始前，交换两个哈希表，并清空\(s_1\)即可。
对于一个轮廓线状态\(x\)，为了操作方便，需要实现两个函数：提取某一位的值、改变某一位的值。上述括号配对表达方式中状态仅有012三种，但我们可以用四进制来表示，因为位运算的效率相对来说会比较高。
总结
插头DP看起来十分难写，但只要自己动手实现一遍，就能理清楚插头DP的基本架构，就会发现它的实现方式其实挺简明的。建议读者还是自我摸索比较好。不过这里还是贴上模板题BZOJ1814的代码：
#include <cstdio>
#define Push(x,y) s[hv].insert((x),(y));
using namespace std;
typedef long long ll;
const int N=13,BAS[13]={1,4,16,64,256,1024,4096,16384,65536,262144,1048576,4194304,16777216};
const int HASH_MOD=4001,S=50000;
int n,m,mp[N][N],ln,lm;
int qcnt,q1[S],hu,hv;
ll q2[S];
ll ans;
char str[N];
inline void swap(int &x,int &y){x^=y^=x^=y;}
inline int get(int st,int x){
st>>=(x-1)<<1;
return st-((st>>2)<<2);
}
inline void mdf(int &st,int x,int y){
st+=(y-get(st,x))*BAS[x-1];
}
int match(int st,int x,int d){
int top=1,stdcol=get(st,x);
for(x+=d;top;x+=d){
int v=get(st,x);
if(v==0) continue;
(v==stdcol)?top++:top--;
}
return x-d;
}
struct Hash{/*{{{*/
int head[S],tot,id[S],nex[S];
ll val[S];
void reset(){
tot=0;
for(int i=0;i<HASH_MOD;i++) head[i]=0;
}
inline int get_hash(int x){return x%HASH_MOD;}
void insert(int x,ll value){
int hs=get_hash(x),u;
for(u=head[hs];u&&id[u]!=x;u=nex[u]);
if(!u){
id[++tot]=x; val[tot]=value;
nex[tot]=head[hs]; head[hs]=tot;
}
else val[u]+=value;
}
void layout(int &n,int *lis1,ll *lis2){
n=0;
for(int i=0;i<HASH_MOD;i++)
for(int u=head[i];u;u=nex[u])
n++,lis1[n]=id[u],lis2[n]=val[u];
}
}s[2];/*}}}*/
void draw(int i,int j){
int a=j,b=j+1,pa,pb;
s[hu].layout(qcnt,q1,q2);
int x; ll y;
while(qcnt){
x=q1[qcnt]; y=q2[qcnt--];
if(!y) continue;
if(j==1) x=(x-get(x,m+1)*BAS[m])<<2;
pa=get(x,a); pb=get(x,b);
if(mp[i][j]==1){
if(!pa&&!pb)
Push(x,y);
continue;
}
if(!pa&&!pb){
if(i<n&&j<m){
mdf(x,a,1); mdf(x,b,2);
Push(x,y);
}
}
else if(pa&&pb){
if(pa==1&&pb==1){
int pos=match(x,b,1);
mdf(x,pos,1);
mdf(x,a,0); mdf(x,b,0);
Push(x,y);
}
else if(pa==2&&pb==2){
int pos=match(x,a,-1);
mdf(x,pos,2);
mdf(x,a,0); mdf(x,b,0);
Push(x,y);
}
else if(pa==1&&pb==2){
if(i==ln&&j==lm){
bool flag=true;
for(int k=1;k<=m+1&&flag;k++) if(k!=a&&k!=b&&get(x,k)) flag=false;
if(flag)
ans+=y;
}
}
else{//pa==2&&pb==1
mdf(x,a,0); mdf(x,b,0);
Push(x,y);
}
}
else{
int u=pa,v=pb;
if(i<n){
mdf(x,a,u+v); mdf(x,b,0);
Push(x,y);
}
if(j<m){
mdf(x,a,0); mdf(x,b,u+v);
Push(x,y);
}
}
}
}
int main(){
scanf("%d%d",&n,&m);
for(int i=1;i<=n;i++){
scanf("%s",str+1);
for(int j=1;j<=m;j++){
if(str[j]=='.') mp[i][j]=0;
else mp[i][j]=1;
if(mp[i][j]!=1) ln=i,lm=j;
}
}
hu=0; hv=1;
s[hu].insert(0,1);
for(int i=1;i<=n;i++)
for(int j=1;j<=m;j++){
draw(i,j);
swap(hu,hv);
s[hv].reset();
}
printf("%lld\n",ans);
return 0;
}
