【Ural】1519. Formula 1 插头DP

【题目】1519. Formula 1

【题意】给定n*m个方格图，有一些障碍格，求非障碍格的哈密顿回路数量。n,m<=12。

【算法】插头DP

【题解】《基于连通性状态压缩的动态规划问题》 by CDQ（万恶之源T_T）

如果你想学最小表示法，当然首推kuangbinの博客。

基本思想是逐格推进，维护轮廓线的m+1个插头的状态，每个插头有一个编号，连通的插头编号相同。

由于只转移和记录有效状态，所以时空复杂度都大大优于普通的状压DP。

1.存储：容易发现连通编号至多0~6，所以用数字每三个二进制位存一个插头编号，用hash表存数字，同状态须合并来保证状态总数。

解码：强制从左到右是从高到低，倒着&7就能解码出数组了。

2.最小表示法：过程中会出现合并编号和新建编号的操作，通过暴力最小化的方法使得编号位0~6，称为最小表示法。

编码：最小化的过程体现在编码，用桶vis记老编号对应的新编号，扫一遍即可。新建的编号设为6。

3.转移：本题的障碍格可以直接不转移，因为插头也不会变化，下面讨论非障碍格的转移（依赖于左插头和上插头）。

Ⅰ存在左插头和上插头

如果同编号，那么只有最后一个非障碍格才能闭合，否则状态无效。

如果不同编号，可以连接，遍历所有插头将和左插头连通的编号改成上插头。

Ⅱ存在左插头或上插头

如果右能加插头就转移，如果下能加插头就转移。

Ⅲ不存在左插头和上插头

如果右和下都能加插头就转移，插头编号6。

#include<cstdio>
#include<cstring>
#include<algorithm>
#define ll long long
using namespace std;
const int maxn=,MOD=,S=;
int c[maxn],map[maxn][maxn],n,m,ex,ey;
struct h{
    int first[MOD],tot,nxt[S];
    ll state[S],ans[S];
    void init(){
        memset(first,,sizeof(first));
        tot=;
    }
    void insert(ll x,ll num){
        for(int i=first[x%MOD];i;i=nxt[i]){
            if(state[i]==x){
                ans[i]+=num;
                return;//!!!
            }
        }
        state[++tot]=x;ans[tot]=num;
        nxt[tot]=first[x%MOD];first[x%MOD]=tot;
    }
}f[];
void decode(ll x){
    for(int i=m;i>=;i--){
        c[i]=x&;
        x>>=;
    }
}
int vis[maxn];//
ll encode(){
    for(int i=;i<=;i++)vis[i]=;
    int cnt=;ll x=;
    for(int i=;i<=m;i++){
        if(!c[i]){x<<=;continue;}
        if(!vis[c[i]])vis[c[i]]=++cnt;
        x=(x<<)|vis[c[i]];
    }
    return x;
}
void solve(int cur,int x,int y){
    for(int k=;k<=f[cur^].tot;k++){
        decode(f[cur^].state[k]);
        int left=c[y-],up=c[y];
        ll ans=f[cur^].ans[k];
        if(left&&up){
            if(left==up){
                if(x==ex&&y==ey){
                    c[y-]=c[y]=;
                    f[cur].insert(encode(),ans);
                }
            }
            else{
                c[y-]=c[y]=;
                for(int i=;i<=m;i++)if(c[i]==left)c[i]=up;
                f[cur].insert(encode(),ans);
            }
        }
        else if(left||up){
            int now=left|up;
            if(map[x+][y]){
                c[y-]=now;c[y]=;
                f[cur].insert(encode(),ans);
            }
            if(map[x][y+]){
                c[y-]=;c[y]=now;
                f[cur].insert(encode(),ans);
            }
        }
        else{
            if(map[x+][y]&&map[x][y+]){
                c[y-]=c[y]=;
                f[cur].insert(encode(),ans);
            }
        }
    }
}
char s[maxn];
int main(){
    scanf("%d%d",&n,&m);
    memset(map,,sizeof(map));
    ex=ey=;
    for(int i=;i<=n;i++){
        scanf("%s",s+);
        for(int j=;j<=m;j++)if(s[j]=='.'){
            map[i][j]=;//
            ex=i;ey=j;
        }
        else map[i][j]=;
    }
    if(!ex){printf("0\n");return ;}
    int cur=;
    f[].init();f[].insert(,);
    for(int i=;i<=n;i++){
        for(int j=;j<=m;j++){
            if(map[i][j])cur^=,f[cur].init(),solve(cur,i,j);
        }
        for(int j=;j<=f[cur].tot;j++)f[cur].state[j]>>=;
    }
    ll ans=;
    for(int i=;i<=f[cur].tot;i++)ans+=f[cur].ans[i];
    printf("%lld\n",ans);
    return ;
}