fzu1977

题解：

和前两题差不多

只不过变成了有些一定走，有些不一定

代码：

#include<cstdio>
#include<cmath>
#include<algorithm>
#include<cstring>
using namespace std;
typedef long long ll;
const int HASH=;
const int STATE=;
int N,M,code[],maze[][],ch[],isend;
struct HASHMAP
{
    int head[HASH],next[STATE],size;
    ll state[STATE],f[STATE];
    void init()
     {
        size=;
        memset(head,-,sizeof(head));
     }
    void push(ll st,ll ans)
     {
        int h=st%HASH;
        for (int i=head[h];i!=-;i=next[i])
         if (state[i]==st)
          {
              f[i]+=ans;
              return;
          }
        state[size]=st;
        f[size]=ans;
        next[size]=head[h];
        head[h]=size++;
     }
}hm[];
void decode(int *code,int m,ll st)
{
    for (int i=m;i>=;i--)
     {
        code[i]=st&;
        st>>=;
     }
    isend=st&;
}
ll encode(int *code,int m)
{
    int cnt=;
    memset(ch,-,sizeof(ch));
    ch[]=;
    ll st=isend;
    for (int i=;i<=m;i++)
     {
        if (ch[code[i]]==-)ch[code[i]]=cnt++;
        code[i]=ch[code[i]];
        st<<=;
        st|=code[i];
     }
    return st;
}
void shift(int *code,int m)
{
    for (int i=m;i>;i--)code[i]=code[i-];
    code[]=;
}  

void dpblank(int i,int j,int cur)
{
    int left,up;
    for (int k=;k<hm[cur].size;k++)
     {
        decode(code,M,hm[cur].state[k]);
        left=code[j-];
        up=code[j];
        if (isend)
         {
            if (left||up||maze[i][j]==)continue;
            code[j-]=code[j]=;
            if (j==M)shift(code,M);
            hm[cur^].push(encode(code,M),hm[cur].f[k]);
            continue;
         }
        if (left&&up)
         {
            if (left==up)
             {
                code[j-]=code[j]=;
                isend=;
                if(j==M)shift(code,M);
                hm[cur^].push(encode(code,M),hm[cur].f[k]);
             }
            else
             {
                code[j-]=code[j]=;
                for (int t=;t<=M;t++)
                 if (code[t]==up)code[t]=left;
                if (j==M)shift(code,M);
                hm[cur^].push(encode(code,M),hm[cur].f[k]);
             }
         }
        else if ((left&&(!up))||((!left)&&up))
         {
            int t;
            if (left)t=left;
            else t=up;
            if (maze[i][j+])
             {
                code[j-]=;
                code[j]=t;
                hm[cur^].push(encode(code,M),hm[cur].f[k]);
             }
            if (maze[i+][j])
             {
                code[j-]=t;
                code[j]=;
                if (j==M)shift(code,M);
                hm[cur^].push(encode(code,M),hm[cur].f[k]);
             }
         }
        else
         {
            if (maze[i][j+]&&maze[i+][j])
             {
                code[j-]=code[j]=;
                hm[cur^].push(encode(code,M),hm[cur].f[k]);
             }
            if (maze[i][j]==)
             {
                code[j-]=code[j]=;
                if (j==M)shift(code,M);
                hm[cur^].push(encode(code,M),hm[cur].f[k]);
             }
         }
     }
}
void dpblock(int i,int j,int cur)
{
    for (int k=;k<hm[cur].size;k++)
     {
        decode(code,M,hm[cur].state[k]);
        code[j-]=code[j]=;
        if (j==M)shift(code,M);
        hm[cur^].push(encode(code,M),hm[cur].f[k]);
     }
}
char str[];
void init()
{
    scanf("%d%d",&N,&M);
    memset(maze,,sizeof(maze));
    for (int i=;i<=N;i++)
     {
        scanf("%s",&str);
        for (int j=;j<=M;j++)
         {
            if (str[j-]=='*')maze[i][j]=;
            else if (str[j-]=='O')maze[i][j]=;
         }
     }
}
void solve()
{
    int cur=;
    hm[cur].init();
    hm[cur].push(,);
    for (int i=;i<=N;i++)
     for (int j=;j<=M;j++)
      {
          hm[cur^].init();
          if(maze[i][j])dpblank(i,j,cur);
          else dpblock(i,j,cur);
          cur^=;
      }
    ll ans=;
    for (int i=;i<hm[cur].size;i++)ans+=hm[cur].f[i];
    printf("%I64d\n",ans);
}
int main()
{
    int T,iCase=;
    scanf("%d",&T);
    while (T--)
     {
        iCase++;
        printf("Case %d: ",iCase);
        init();
        solve();
     }
    return ;
}