【插头DP】BZOJ1187- [HNOI2007]神奇游乐园

【题目大意】

在n*m的网格中选一条回路，使权值和最大。

【思路】

和之前裸的插头DP差不多，只不过现在回路不需要经过所有的格子。所以有以下几个注意点（具体看注释）:

(1)left和up插头相等的时候，直接更新答案;

(2)left和up插头不存在的时候，还要考虑当前格子不取的情况。

orz写了半天，感觉被掏空.jpg

 #include<bits/stdc++.h>
 using namespace std;
 typedef long long ll;
 const int MAXN=;
 const int MAXM=;
 const int HASH=;
 const int INF=0x7fffffff;
 ll ans=-1ll << ;
 int n,m,sat[MAXM][MAXN];
 int code[MAXN];

 struct HashMap
 {
     vector<int> hash[HASH];
     vector<ll> state,f;

     void clear()
     {
         for(int i=;i<HASH;i++) vector<int>().swap(hash[i]);
         vector<ll>().swap(state);
         vector<ll>().swap(f);
     }

     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]=max(f[now],ans);
                 return;
             }
         }
         state.push_back(st);
         f.push_back(ans);
         hash[h].push_back(state.size()-);
     }
 }dp[];

 void decode(ll state)
 {
     memset(code,,sizeof(code));
     for (int i=n;i>=;i--)
     {
         code[i]=state&;
         state>>=;
     }
 }

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

 ll encode()
 {
     int ch[MAXN],cnt=;
     memset(ch,-,sizeof(ch));
     ch[]=;
     ll ret=;
     for (int i=;i<=n;i++)
     {
         if (ch[code[i]]==-) ch[code[i]]=++cnt;
         code[i]=ch[code[i]];
         ret<<=;
         ret|=code[i];
     }
     return ret;
 }

 void dpblank(int i,int j,int cur)
 {
     for (int k=;k<dp[-cur].state.size();k++)
     {
         decode(dp[-cur].state[k]);
         if (j==)//把之前shift的写法改成这样写了，总之就过了，也不知道为什么orz
         {
             if (code[n]) continue;
             shift();
         }
         int left=code[j-],up=code[j];

         if (left && up)
         {
             code[j-]=code[j]=;
             if (left==up)
             {
                 if (encode()==) ans=max(ans,dp[-cur].f[k]+sat[i][j]);
                 //注意和之前不一样的地方：如果已经封闭起来了就更新答案
             }
             else
             {
                 for (int t=;t<=n;t++) if (code[t]==left) code[t]=up;
                 dp[cur].push(encode(),dp[-cur].f[k]+sat[i][j]);
             }
         }

         if ((left && (!up)) || (up && (!left)))
         {
             int t=left|up;
             code[j-]=;
             code[j]=t;
             dp[cur].push(encode(),dp[-cur].f[k]+sat[i][j]);
             code[j-]=t;
             code[j]=;
             dp[cur].push(encode(),dp[-cur].f[k]+sat[i][j]);
         }

         if (!left && !up)
         {
             dp[cur].push(encode(),dp[-cur].f[k]);
             //注意并不一定是所有格子都要经过，所以还要考虑不经过当前格子的情况
             code[j-]=code[j]=MAXN-;
             dp[cur].push(encode(),dp[-cur].f[k]+sat[i][j]);
         }
     }
 }

 void init()
 {
     scanf("%d%d",&m,&n);
     for (int i=;i<=m;i++)
         for (int j=;j<=n;j++) scanf("%d",&sat[i][j]);
 }

 void solve()
 {
     int cur=;
     dp[cur].clear();
     dp[cur].push(,);
     for (int i=;i<=m;i++)
         for (int j=;j<=n;j++)
         {
             cur^=;
             dp[cur].clear();
             dpblank(i,j,cur);
         }
     printf("%lld",ans);
 }

 int main()
 {
     init();
     solve();
     return ;
 }