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 = 15, HASH = 30007, STATE = 100010;
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 = 0, mset(head, -1); }
    void push(LL x, LL add)
    {
        int pos = x%HASH, i = head[pos];
        for (; i != -1; 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[2];

void in()
{
    scanf("%d %d", &n, &m), mset(maze, 0), end_x = end_y = -1;
    REP(i, 1, n)
    {
        scanf("%s", str+1);
        REP(j, 1, m) 
            if (str[j] == '.')
                maze[i][j] = 1, end_x = i, end_y = j;
    }
}

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

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

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

void dp_blank(int i, int j, int cur)
{
    REP(k, 0, hm[cur].siz-1)
    {
        decode(hm[cur].state[k]);
        int lef = code[j-1], up = code[j];
        if (lef && up)
        {
            if (lef == up && !(i == end_x && j == end_y)) continue ;
            REP(t, 0, m)
                if (code[t] == up) code[t] = lef;
            code[j-1] = code[j] = 0, shift(j);
            hm[cur^1].push(encode(), hm[cur].f[k]);
        }
        else
            if (lef || up)
            {
                int t = lef ? lef : up;
                if (maze[i][j+1])
                {
                    code[j-1] = 0, code[j] = t;
                    hm[cur^1].push(encode(), hm[cur].f[k]);
                }
                if (maze[i+1][j])
                {
                    code[j-1] = t, code[j] = 0, shift(j);
                    hm[cur^1].push(encode(), hm[cur].f[k]);
                }
            }
            else
                if (maze[i][j+1] && maze[i+1][j])
                {
                    code[j-1] = code[j] = 13, shift(j);
                    hm[cur^1].push(encode(), hm[cur].f[k]);
                }
    }
}

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

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

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