HDU 1964 Pipes （插头DP，变形）

题意：给一个n*m的矩阵，每个格子都是必走的，且无障碍格子，每对格子之间都有一个花费，问哈密顿回路的最小花费。

思路：

　　这个和Formula1差不多，只是求得是最小花费，这只需要修改一下DP值为花费就行了，主要是在创建新括号，以及延续一个插头的时候花费，因为可能上一个格子有多个状态都可以转移到本格子的同一状态，那么同一个格子中的同一状态的DP值取最小值即可。

 #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=;

 int g[N][N], cur, n, m;
 struct Hash_Map
 {
     static const int mod=;
     static const int NN=;
     int head[mod];      //桶指针
     int next[NN];        //记录链的信息
     LL  status[NN];      //状态
     LL  value[NN];       //状态对应的DP值。
     int size;

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

     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] = min(value[i], val);
                 return ;
             }
         status[size]= st;           //找不到状态st，则插入st。
         value[size] = val;
         next[size] = head[h] ;      //新插入的元素在队头
         head[h] = size++;
     }
 }hashmap[];

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

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

 void DP(int i,int j)
 {
     LL t;
     for(int k=; k<hashmap[cur^].size; k++)
     {
         LL s=hashmap[cur^].status[k];
         LL v=hashmap[cur^].value[k];
         int R=getbit(s, j), D=getbit(s, j+);
         if(R && D)  //两个括号
         {
             t=(setbit(s,j,)&setbit(s,j+,));
             if(R==D)    //同个方向的括号
             {
                 if(R==)    t=Fr(t, j, );  //要改
                 else        t=Fl(t, j, );
                 hashmap[cur].insert(t, v);
             }
             else if( R== && D== )        //不同的连通分量
                 hashmap[cur].insert(t, v);
             else if( i+==n && j+==m && t== )        //终点才能闭合
                 hashmap[cur].insert(t, v);
         }
         else if(R || D)     //仅1个括号
         {
             if(R)   //右插头
             {
                 if(i+<n )   hashmap[cur].insert(s, v+g[i*m+j+][i*m+m+j+]);//往下
                 if(j+<m )   hashmap[cur].insert(setbit(setbit(s,j,), j+, R), v+g[i*m+j+][i*m+j+]);//往右
             }
             else    //下插头
             {
                 if(j+<m )   hashmap[cur].insert(s, v+g[i*m+j+][i*m+j+]); //往右
                 if(i+<n )   hashmap[cur].insert(setbit(setbit(s,j+,), j, D), v+g[i*m+j+][i*m+m+j+]);//往下
             }
         }
         else                //无括号
         {
             if(  j+<m && i+<n )    //新括号
             {
                 v+=g[i*m+j+][i*m+m+j+];   //下
                 v+=g[i*m+j+][i*m+j+];     //右
                 hashmap[cur].insert( setbit(s,j,)|setbit(s,j+,), v);
             }
         }
     }
 }

 void cal()
 {
     for(int i=; i<n; i++)
     {
         cur^=;
         hashmap[cur].clear();
         for(int j=; j<hashmap[cur^].size; j++)    //新行，需要左移一下状态。
             hashmap[cur].insert( hashmap[cur^].status[j]<<, hashmap[cur^].value[j] );
         for(int j=; j<m; j++)
         {
             cur^=;
             hashmap[cur].clear();
             DP(i,j);
         }
     }
 }
 LL print()
 {
     for(int i=; i<hashmap[cur].size; i++)
         if(hashmap[cur].status[i]==)
             return hashmap[cur].value[i];
     return ;
 }

 int main()
 {
     //freopen("input.txt", "r", stdin);
     int t, Case=;
     cin>>t;
     while(t--)
     {
         memset(g,,sizeof(g));
         n=m=cur=;
         scanf("%d%d",&n,&m);
         for(int i=; i<n; i++)      //输入
         {
             for(int j=; j<m; j++)  //左右
             {
                 char c=getchar();
                 if(isdigit(c))
                     g[i*m-m+j][i*m-m+j+]=g[i*m-m+j+][i*m-m+j]=c-'';
                 else j--;
             }
             for(int j=; j<=m; j++) //上下
             {
                 char c=getchar();
                 if(isdigit(c))
                     g[i*m-m+j][i*m+j]=g[i*m+j][i*m-m+j]=c-'';
                 else j--;
             }
         }
         for(int j=; j<m; j++)      //最后一行：左右
         {
             char c=getchar();
             if(isdigit(c))
                 g[n*m-m+j][n*m-m+j+]=g[n*m-m+j+][n*m-m+j]=c-'';
             else j--;
         }
         char s[];
         scanf("%s%s",s,s);//多余

         hashmap[cur].clear();
         hashmap[cur].insert(, );  //初始状态:花费0
         cal();
         cout<<print()<<endl;
     }
     return ;
 }

AC代码