【插头DP】BZOJ3125-city

开学忙成狗，刷题慢如蜗牛……

【题目大意】

给出一个m*n的矩阵里面有一些格子为障碍物，一些格子只能上下通行，一些格子只能左右通行，一些格子上下左右都能通行。问经过所有非障碍格子的哈密顿回路个数。

【思路】

和BZOJ1814差不多，增加几个比较简单的判断即可。详见代码。

【错误点】

一开始我把三种可通行的情况写在一起，有点混乱了……拆开成3个函数就好啦！

下次注意程序的可读性。

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #include<vector>
 using namespace std;
 typedef long long ll;
 const int MAXN=;
 const int HASH=;
 int ex,ey;
 int m,n;
 int maze[MAXN][MAXN];
 int code[MAXN],ch[MAXN];
 struct HashMap
 {
     vector<int> hash[HASH];//存储f和state的下标
     vector<ll> f,state;//存储对应的方案数和状态
     void init()
     {
         for (int i=;i<HASH;i++) vector<int>().swap(hash[i]);
         vector<ll>().swap(f);
         vector<ll>().swap(state);
     }
     void push(ll st,ll ans)
     {
         int h=st%HASH;
         for (int i=;i<hash[h].size();i++)
         {
             int now=hash[h][i];
             if (state[now]==st)//如果已经存储了当前状态，直接累加
             {
                 f[now]+=ans;
                 return;
             }
         }
         //如果没有存储过当前状态，累加
         state.push_back(st);
         f.push_back(ans);
         hash[h].push_back(state.size()-);
     }
 }dp[];

 void decode(ll st)
 {
     memset(code,,sizeof(code));
     for (int i=n;i>=;i--)
     {
         code[i]=st&;//每三位代表一个信息
         st>>=;
     }
 }

 ll encode()
 //用最小表示法重新编码
 {
     int cnt=;
     memset(ch,-,sizeof(ch));
     ch[]=;
     long long st=;
     for (int i=;i<=n;i++)
     {
         if (ch[code[i]]==-) ch[code[i]]=cnt++;
         code[i]=ch[code[i]];
         st<<=;
         st|=code[i];
     }
     return st;
 }

 void shift()
 {
     for (int i=n;i>;i--) code[i]=code[i-];
     code[]=;
 }

 void dpblank(int i,int j,int cur)
 {
     for (int k=;k<dp[-cur].state.size();k++)
     {
         decode(dp[-cur].state[k]);
         int left=code[j-];//左插头
         int up=code[j];//上插头

         /*如果上下插头都没有*/
         if (!left && !up)
         {
             if (maze[i][j+] && maze[i+][j])
             {
                 code[j-]=code[j]=MAXN-;
                 //这里只要随便设置一个大数即可

                 //【attention】这里千万不可以设置成MAXN，否则ch数组会抱★★★★★★★★

                 //因为encode会重新用最小表示法编码
                 dp[cur].push(encode(),dp[-cur].f[k]);
             }
         }

         /*只有上插头或者只有左插头*/
         if ((left&&(!up))||((!left)&&up))
         {

             int t=left|up;
             if (maze[i][j+])//右边没有障碍
             {
                 code[j-]=;
                 code[j]=t;
                 dp[cur].push(encode(),dp[-cur].f[k]);
             }
             if (maze[i+][j])//下面没有障碍
             {
                 code[j-]=t;
                 code[j]=;
                 if (j==n) shift();
                 dp[cur].push(encode(),dp[-cur].f[k]);
             }
         }

         /*上插头和右插头都有*/
         if (left && up)
         {
             if (left==up)
             {
                 if (i==ex && j==ey)
                 {
                     code[j-]=code[j]=;
                     if (j==n) shift();
                     dp[cur].push(encode(),dp[-cur].f[k]);
                 }
             }
             else
             {
                 code[j-]=code[j]=;
                 for (int t=;t<=n;t++)
                     if (code[t]==up) code[t]=left;
                 if (j==n) shift();
                 dp[cur].push(encode(),dp[-cur].f[k]);
             }
         }
     }
 }

 void DpHorizon(int cur,int i,int j)//只能水平走
 {
     for (int k=;k<dp[-cur].state.size();k++)
     {
         decode(dp[-cur].state[k]);
         int left=code[j-],up=code[j];

         if(!up && left&& maze[i][j+]!= && maze[i][j+]!=&& j!=n&&j!=) //右边不是障碍物，也能够水平走,并且不是最右边
         {
             code[j-]=;
             code[j]=left;
             dp[cur].push(encode(),dp[-cur].f[k]);
         }
     } 

 }

 void DpVertical(int cur,int i,int j)//只能竖直走
 {
     for (int k=;k<dp[-cur].state.size();k++)
     {
         decode(dp[-cur].state[k]);
         int left=code[j-],up=code[j];

         if(up && !left && maze[i+][j]!= && maze[i+][j]!=&&i!=m&&i!=)//下边不是障碍物，也能够竖直走
         {
             code[j-]=up;
             code[j]=;
             if(j==n)shift();
             dp[cur].push(encode(),dp[-cur].f[k]);
         }
     } 

 }

 void dpblock(int i,int j,int cur)
 {
     int k=;
     for (int k=;k<dp[-cur].state.size();k++)
     {
         decode(dp[-cur].state[k]);
         code[j-]=code[j]=;
         if (j==n) shift();
         dp[cur].push(encode(),dp[-cur].f[k]);
     }
 }

 void solve()
 {
     int cur=;
     ll ans=;
     dp[cur].init();
     dp[cur].push(,);//DP数组初始化
     for (int i=;i<=m;i++)
         for (int j=;j<=n;j++)
         {
             cur^=;
             dp[cur].init();
             if (maze[i][j]==) dpblank(i,j,cur);
                 else if (maze[i][j]==)  dpblock(i,j,cur);
                 else if  (maze[i][j]==)DpHorizon(cur,i,j);
                 else  DpVertical(cur,i,j);
         }
     for (int i=;i<dp[cur].state.size();i++)
         ans+=dp[cur].f[i];
     printf("%lld",ans);
 }

 void init()
 {
     scanf("%d%d",&m,&n);
     for (int i=;i<=m;i++)
     {
         char str[MAXN];
         scanf("%s",str);
         for (int j=;j<=n;j++)
         {
             if (str[j-]=='#') maze[i][j]=;
             if (str[j-]=='.') maze[i][j]=;
             if (str[j-]=='-') maze[i][j]=;
             if (str[j-]=='|') maze[i][j]=;
             if (str[j-]!='#') ex=i,ey=j;
         }
     }
 }

 int main()
 {

     init();
     if (ex==) puts("");//如果没有一个是空格的话直接输出0
         else solve();

 }