Ural 1519 Formula 1 插头DP

　　这是一道经典的插头DP单回路模板题。

　　用最小表示法来记录连通性，由于二进制的速度，考虑使用8进制。

　　1、当同时存在左、上插头的时候，需要判断两插头所在连通块是否相同，若相同，只能在最后一个非障碍点相连；若不相同，则把这两个连通块连起来。

　　2、如果只存在左或上插头的时候，则要延续连通块。

　　3、若都不存在左和上插头的时候，就要新建一个连通块。

 #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))
 typedef long long LL;
 const int MAXD = , HASH = , STATE = ;
 int n, m, maze[MAXD][MAXD], code[MAXD], ch[MAXD], end_x, end_y;
 char str[MAXD];
 struct HASHMAP
 {
     int head[HASH], nxt[STATE], siz; LL f[STATE], state[STATE];
     void clear() { siz = , mset(head, -); }
     void push(LL x, LL add)
     {
         int pos = x%HASH, i = head[pos];
         for (; i != -; i = nxt[i])
             if (state[i] == x) { 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, ), end_x = end_y = -;
     REP(i, , n)
     {
         scanf("%s", str+);
         REP(j, , m)
             if (str[j] == '.')
                 maze[i][j] = , end_x = i, end_y = j;
     }
 }

 void decode(LL x)
 {
     REP(i, , m) code[i] = x&, x >>= ;
 }

 LL encode()
 {
     LL ret = ; int cnt = ;
     mset(ch, -), ch[] = ;
     DWN(i, m, )
     {
         if (ch[code[i]] == -) ch[code[i]] = ++cnt;
         ret <<= , ret |= ch[code[i]];
     }
     return ret;
 }

 void shift(int j)
 {
     if (j != m) return ;
     DWN(i, m, ) code[i] = code[i-];
     code[] = ;
 }

 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 && !(i == end_x && j == end_y)) continue ;
             REP(t, , m)
                 if (code[t] == up) code[t] = lef;
             code[j-] = code[j] = , shift(j);
             hm[cur^].push(encode(), hm[cur].f[k]);
         }
         else
             if (lef || up)
             {
                 int t = lef ? lef : up;
                 if (maze[i][j+])
                 {
                     code[j-] = , code[j] = t;
                     hm[cur^].push(encode(), hm[cur].f[k]);
                 }
                 if (maze[i+][j])
                 {
                     code[j-] = t, code[j] = , shift(j);
                     hm[cur^].push(encode(), hm[cur].f[k]);
                 }
             }
             else
                 if (maze[i][j+] && maze[i+][j])
                 {
                     code[j-] = code[j] = , shift(j);
                     hm[cur^].push(encode(), hm[cur].f[k]);
                 }
     }
 }

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

 void work()
 {
     int cur = ; LL ans = ;
     hm[].clear(), hm[].clear(), hm[cur].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 ^= ;
         }
     REP(i, , hm[cur].siz-) ans += hm[cur].f[i];
     printf("%I64d\n", ans);
 }

 int main()
 {
     in();
     work();
     return ;
 }