ZOJ 3213 Beautiful Meadow 简单路径 插头DP

　　简单路径的题目，其实就是在状态后面多记了有多少个独立插头。

　　分类讨论独立插头：

　　1、只存在上插头或者左插头，可以选择作为独立插头。

　　2、都不存在上插头和左插头，选择作为独立插头的同时要标号为新的连通块。

　　换行时需特别注意，因为还有独立插头的判断，如果进行了换行操作，就会乱，特别是在不存在上插头和左插头的情况下。

　　那要怎么办呢？

　　我们会发现，换行后，1~m-1往后移，并把code[0]设为0，但我们在encode的时候，code[0] = 0，其实是可以忽略的操作，那么我们只需要做M-1就可以了。

　　这样想来，就可以去掉shift的操作了。

 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
 #include <string>
 #include <algorithm>

 using namespace std;

 #define REP(i, a, b) for (int i = (a), i##_end_ = (b); i <= i##_end_; ++i)
 #define DWN(i, a, b) for (int i = (a), i##_end_ = (b); i >= i##_end_; --i)
 #define mset(a, b) memset(a, b, sizeof(a))
 const int MAXD = , HASH = , STATE = ;
 int n, m, maze[MAXD][MAXD], code[MAXD], ch[MAXD];
 int text[MAXD];

 void Ckmax(int &AI, int BI) { if (AI < BI) AI = BI; }

 struct HASHMAP
 {
     int head[HASH], nxt[STATE], state[STATE], f[STATE], siz;
     void clear() { siz = , mset(head, -); }
     void push(int x, int add)
     {
         int pos = x%HASH, i = head[pos];
         for (; i != -; i = nxt[i])
             if (state[i] == x) { Ckmax(f[i], add); return ; }
         state[siz] = x, f[siz] = add;
         nxt[siz] = head[pos], head[pos] = siz++;
     }
 }hm[];

 void in()
 {
     scanf("%d %d", &n, &m), mset(maze, );
     REP(i, , n)
         REP(j, , m) scanf("%d", &maze[i][j]);
 }

 void decode(int x)
 {
     DWN(i, m+, ) code[i] = x&, x >>= ;
 }

 int encode(int j)//WRONG 由于换行不能修改，要这样做
 {
     int ret = , cnt = , lim = (j == m) ? m- : m;
     mset(ch, -), ch[] = ;
     REP(i, , lim)
     {
         if (ch[code[i]] == -) ch[code[i]] = ++cnt;
         ret <<= , ret |= ch[code[i]];
     }
     ret <<= , ret |= code[m+];
     return ret;
 }

 void dp_blank(int i, int j, int cur)
 {
     REP(k, , hm[cur].siz-)
     {
         decode(hm[cur].state[k]);
         int lef = code[j-], up = code[j];
         if (lef && up)
         {
             if (lef == up) continue ;
             REP(t, , m)
                 if (code[t] == up) code[t] = lef;
             code[j-] = code[j] = ;
             hm[cur^].push(encode(j), hm[cur].f[k]+maze[i][j]);
         }
         else
         {
             if (lef || up)
             {
                 int t = lef ? lef : up;
                 if (maze[i][j+])
                 {
                     code[j-] = , code[j] = t;
                     hm[cur^].push(encode(j), hm[cur].f[k]+maze[i][j]);
                 }
                 if (maze[i+][j])
                 {
                     code[j-] = t, code[j] = ;
                     hm[cur^].push(encode(j), hm[cur].f[k]+maze[i][j]);
                 }
                 if (code[m+]++ < )
                 {
                     code[j-] = code[j] = ;
                     hm[cur^].push(encode(j), hm[cur].f[k]+maze[i][j]);
                 }
             }
             else
             {
                 hm[cur^].push(encode(j), hm[cur].f[k]);
                 if (maze[i][j+] && maze[i+][j])//WRONG
                 {
                     code[j-] = code[j] = ;
                     hm[cur^].push(encode(j), hm[cur].f[k]+maze[i][j]);
                 }
                 if (code[m+]++ > ) continue ;
                 if (maze[i][j+])
                 {
                     code[j-] = , code[j] = ;
                     hm[cur^].push(encode(j), hm[cur].f[k]+maze[i][j]);
                 }
                 if (maze[i+][j])
                 {
                     code[j-] = , code[j] = ;
                     hm[cur^].push(encode(j), hm[cur].f[k]+maze[i][j]);
                 }
             }
         }
     }
 }

 void dp_block(int i, int j, int cur)
 {
     REP(k, , hm[cur].siz-)
     {
         decode(hm[cur].state[k]);
         code[j-] = code[j] = ;
         hm[cur^].push(encode(j), hm[cur].f[k]);
     }
 }

 void work()
 {
     int cur = , ans = ;
     hm[].clear(), hm[].clear(), hm[].push(, );
     REP(i, , n)
         REP(j, , m)
         {
             if (maze[i][j]) dp_blank(i, j, cur);
             else dp_block(i, j, cur);
             hm[cur].clear(), cur ^= ;
             Ckmax(ans, maze[i][j]);
         }
     REP(i, , hm[cur].siz-) Ckmax(ans, hm[cur].f[i]);
     printf("%d\n", ans);
 }

 int main()
 {
     int T;
     scanf("%d", &T);
     while (T --) in(), work();
     return ;
 }