【BZOJ】2331: [SCOI2011]地板 插头DP

【题意】给定n*m的地板，有一些障碍格，要求用L型的方块不重不漏填满的方案数。L型方块是从一个方格向任意两个相邻方向延伸的方块，不能不延伸。n*m<=100。

【算法】插头DP

【题解】状态0表示无插头，1表示能拐弯的插头，2表示不能拐弯的插头。（有插头，方块就必须必须延伸到该格），考虑转移即可。

注意可以凭空产生一个能拐弯的插头。

n*m<=100，当m>10的时候将i,j互换。

#include<cstdio>
#include<cstring>
#include<algorithm>
#define ll long long
using namespace std;
const int maxn=,MM=,MOD=,S=;
int map[maxn][maxn],n,m,c[maxn];
int M(int x){return x>=MM?x-MM:x;}
struct h{
    int state[S],ans[S],first[MOD],tot,nxt[S];
    void init(){
        memset(first,,sizeof(first));
        tot=;
    }
    void insert(int x,int num){
        for(int i=first[x%MOD];i;i=nxt[i])if(state[i]==x){
            ans[i]=M(ans[i]+num);
            return;
        }
        state[++tot]=x;ans[tot]=num;
        nxt[tot]=first[x%MOD];first[x%MOD]=tot;
    }
}f[];
void decode(int x){for(int i=m;i>=;i--)c[i]=x&,x>>=;}
int encode(){int x=;for(int i=;i<=m;i++)x=(x<<)|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 ans=f[cur^].ans[k],left=c[y-],up=c[y];
        if(left==){
            if(up==){
                if(map[x][y+]&&map[x+][y]){
                    c[y-]=;c[y]=;
                    f[cur].insert(encode(),ans);
                }
                if(map[x+][y]){
                    c[y-]=;c[y]=;
                    f[cur].insert(encode(),ans);
                }
                if(map[x][y+]){
                    c[y-]=;c[y]=;
                    f[cur].insert(encode(),ans);
                }
            }
            if(up==){
                if(map[x+][y]){
                    c[y-]=;c[y]=;
                    f[cur].insert(encode(),ans);
                }
                if(map[x][y+]){
                    c[y-]=;c[y]=;
                    f[cur].insert(encode(),ans);
                }
            }
            if(up==){
                if(map[x+][y]){
                    c[y-]=;c[y]=;
                    f[cur].insert(encode(),ans);
                }
                c[y-]=;c[y]=;
                f[cur].insert(encode(),ans);
            }
        }
        if(left==){
            if(up==){
                if(map[x+][y]){
                    c[y-]=;c[y]=;
                    f[cur].insert(encode(),ans);
                }
                if(map[x][y+]){
                    c[y-]=;c[y]=;
                    f[cur].insert(encode(),ans);
                }
            }
            if(up==){
                c[y-]=c[y]=;
                f[cur].insert(encode(),ans);
            }
        }
        if(left==){
            if(up==){
                if(map[x][y+]){
                    c[y-]=;c[y]=;
                    f[cur].insert(encode(),ans);
                }
                c[y-]=;c[y]=;
                f[cur].insert(encode(),ans);
            }
        }
    }
}
char s[maxn];
int main(){
    scanf("%d%d",&n,&m);
    for(int i=;i<=n;i++){
        scanf("%s",s+);
        for(int j=;j<=m;j++)if(s[j]=='_'){
            if(m<=)map[i][j]=;else map[j][i]=;
        }
    }
    if(m>)swap(n,m);
    int cur=;f[].init();f[].insert(,);
    for(int i=;i<=n;i++){
        for(int j=;j<=m;j++)if(map[i][j]){
            f[cur^=].init(),solve(cur,i,j);
        }
        for(int j=;j<=f[cur].tot;j++)f[cur].state[j]>>=;
    }
    int ans=;
    for(int i=;i<=f[cur].tot;i++)ans=M(ans+f[cur].ans[i]);
    printf("%d",ans);
    return ;
}

经历：开始看错题，以为是向右向下延伸的方块，就1表示可以延伸的插头，2表示必须延伸的插头。

但其实这也是不必要的，插头DP通常强制限定插头指向的方块必须选择，而在之前插的时候提前判断是否能选。