FZU 1977 Pandora adventure （插头DP，常规）

题意：有一个n*m矩阵，其中有些格子必走，有些格子不可走，其他格子是可走也可不走，问有多少条哈密顿回路？

思路：

　　本来是一道很简单的题，代码写多了连白痴bug都查不出了，竟然用i>=ex&&j>=ey来判定最后一个必走点后面的点！明显是错的。

　　其实主要在选走的格子，那么有两种选择，“走”or“不走”，不走的话上一个格子的状态照搬过来。这样就没有了固定的终点了，因为终点可以是很多种情况（比如是选走点/必走点），那么只要是在ex和ey后面的格子（指的是(ex,ey)之后遍历的所有非障碍格子），都是可以作为终点的，只有在这些格子才可以将左右括号连起来（只统计但不插入）。其他的基本和常规的一样了，本次仍然用括号表示法，再过滤掉很多无效的状态，所以代码略长，但容易看。

//#include <bits/stdc++.h>
#include <iostream>
#include <cstdio>
#include <cstring>
#define pii pair<int,int>
#define INF 0x3f3f3f3f
#define LL long long
using namespace std;
const int N=20;
const int mod=12357;
const int NN=100010;
char g[N][N];
LL ans;
int cur, n, m, ex, ey, tx, ty;
struct Hash_Map
{
    int head[mod];      //桶指针
    int next[NN];        //记录链的信息
    LL  status[NN];      //状态
    LL  value[NN];       //状态对应的DP值。
    int size;

    void clear()    //清除哈希表中的状态
    {
        memset(head, -1, sizeof(head));
        size = 0;
    }

    void insert(LL st, LL val)  //插入状态st的值为val
    {
        int h = st%mod;
        for(int i=head[h]; ~i; i=next[i])
            if(status[i] == st) //这个状态已经存在，累加进去。
            {
                value[i] += val;
                return ;
            }
        status[size]= st;           //找不到状态st，则插入st。
        value[size] = val;
        next[size] = head[h] ;      //新插入的元素在队头
        head[h] = size++;
    }
}hashmap[2];

inline int getbit(LL s,int pos)   //取出状态s的第pos个插头
{
    return (s>>2*pos)&3;
}
inline int setbit(LL s,int pos,int bit)   //将状态s的第pos个插头设置为bit
{
    if(s&(1<<2*pos ))     s^=1<<(2*pos);
    if(s&(1<<(2*pos+1)))  s^=1<<(2*pos+1);
    return (s|(bit<<2*pos));
}

int Fr(LL s,int pos,int bit)   //寻找状态s的第pos个插头对应的右括号。
{
    int cnt=0;
    for(pos+=2; pos<m; pos++)
    {
        if(getbit(s, pos)==3-bit)   cnt++;
        if(getbit(s, pos)==bit)     cnt--;
        if(cnt==-1)         return setbit(s, pos, 3-bit);
    }
}
int Fl(LL s,int pos,int bit)   //寻找状态s的第pos个插头对应的左括号。
{
    int cnt=0;
    for(pos--; pos>=0; pos--)
    {
        if(getbit(s, pos)==3-bit)  cnt++;
        if(getbit(s, pos)==bit)    cnt--;
        if( cnt==-1)    return setbit(s, pos, 3-bit);
    }
}

void DP(int i,int j)    //非障碍空格
{
    LL t;
    for(int k=0; k<hashmap[cur^1].size; k++)
    {
        LL s=hashmap[cur^1].status[k];
        LL v=hashmap[cur^1].value[k];
        int R=getbit(s,j), D=getbit(s,j+1);
        if(g[i][j]=='X')    //障碍格子
        {
            if( R==0 && D==0 )    hashmap[cur].insert(s, v);
            continue ;
        }
        if(R && D)  //两个括号
        {
            t=(setbit(s,j,0)&setbit(s,j+1,0));
            if(R==D)    //同个方向的括号
            {
                if(R==1)    t=Fr(t, j, 2);  //要改
                else        t=Fl(t, j, 1);
                hashmap[cur].insert(t, v);
            }
            else if( R==2 && D==1 )        //不同的连通分量
                hashmap[cur].insert(t, v);
            else if(t==0 && ( i>ex || (i==ex && j>=ey)))    //注意点！
                ans+=v;
        }
        else if(R || D)     //仅1个括号
        {
            if(R)
            {
                if(i+1<n && g[i+1][j]!='X')   hashmap[cur].insert(s, v);
                if(j+1<m && g[i][j+1]!='x')   hashmap[cur].insert(setbit(setbit(s,j,0), j+1, R), v);
            }
            else
            {
                if(j+1<m && g[i][j+1]!='X')   hashmap[cur].insert(s, v);
                if(i+1<n && g[i+1][j]!='X')   hashmap[cur].insert(setbit(setbit(s,j+1,0), j, D), v);
            }
        }
        else                //无括号
        {
            if( g[i][j+1]!='X' && g[i+1][j]!='X' && j+1<m && i+1<n )    //新括号
                hashmap[cur].insert( setbit(s,j,1)|setbit(s,j+1,2), v);
            if( g[i][j]=='*' )      //此点可不走
                hashmap[cur].insert( s, v);
        }
    }
}

void cal()
{
    for(int i=0; i<n; i++)
    {
        cur^=1;
        hashmap[cur].clear();
        for(int j=0; j<hashmap[cur^1].size; j++)    //新行，需要左移一下状态。
            hashmap[cur].insert( hashmap[cur^1].status[j]<<2, hashmap[cur^1].value[j] );
        for(int j=0; j<m; j++)
        {
            cur^=1;
            hashmap[cur].clear();
            DP(i,j);
            if(i==tx && j==ty)    return ;  //最后的有效点
        }
    }
}


int main()
{
    //freopen("input.txt", "r", stdin);
    int t, Case=0;
    cin>>t;
    while(t--)
    {
        tx=ty=ex=ey=-1;
        ans=cur=0;
        memset(g, 'X', sizeof(g));
        scanf("%d%d",&n,&m);
        for(int i=0; i<n; i++)      //输入矩阵
        {
            for(int j=0; j<m; j++)
            {
                char c=getchar();
                if(c=='X'||c=='*'||c=='O')
                {
                    g[i][j]=c;
                    if( c=='O' )    ex=i,ey=j;  //必走格
                    if( c!='X' )    tx=i,ty=j;  //终点格
                }
                else    j--;
            }
        }

        hashmap[cur].clear();
        hashmap[cur].insert(0, 1);  //初始状态
        cal();
        cout<<"Case "<<++Case<<": "<<ans<<endl;
    }
    return 0;
}