HDU4285 circuits 插头dp

原题：HDU4285

题意：N*M有障碍矩阵，“*”为障碍，求用多个回路覆盖所有非障碍点，要求回路之间不能嵌套，求回路数为K的方案数（1 <= n,m <=12)。

解：
插头dp
相比耿直的多回路问题，这题多了两个要求，一是k个回路，二是回路之间不能嵌套。
对于第一个要求，显然，在储存当前轮廓线的插头状态时，还要储存已产生的回路数，最大为K，因为回路至少4格，所以K最大值为12*12/4 = 36，需要6位二进制（写的时候智障地用了8位，影响不大）。
对于第二个要求，在每个状态转移的时候，若轮廓线前面的插头数为奇数，则意味着会产生嵌套，为非法情况。
(1).障碍点
只有没有左，上插头的状态，转移到没有右，下插头的状态
(2).非障碍点

1. 有左，上插头：如果左，上插头连通，合并左上插头，并且要满足条件2使得轮廓线上该列以前的插头数为偶数，如果左，上插头不连通，合并左上插头，并将轮廓线上的上插头连通块加入到左插头连通块中。
2. 只有左插头或者只有上插头：延续插头的连通性，转移到只有右插头或只有下插头的状态。
3. 没有左，上插头：新建连通块，有右，下插头，标号为八进制中的7。

代码如下：

#include <cstdio>
#include <iostream>
#include <cstring>
#include <queue>
#include <algorithm>
#include <cmath>
using namespace std;
#define N 15
#define inf 0x7f7f7f7f
#define mod 1000000007
#define HASH 10007
#define STATE 1000100
typedef long long ll;
int n, m, l;
int code[N], ch[N];
int mp[N][N];

struct HASHMAP
{
    int head[HASH], next[STATE], size;
    ll f[STATE], state[STATE];
    void init() {
        size = 0;
        memset(head, -1, sizeof(head));
    }
    void push(ll st, ll ans) {
        int h = st % HASH;
        for (int i = head[h]; i != -1; i = next[i]) {
            if (state[i] == st) {
                f[i] = (f[i] + ans) % mod;
                return;
            }
        }
        state[size] = st;
        f[size] = ans;
        next[size] = head[h];
        head[h] = size++;
    }
}hm[2];

void decode(ll st)
{
    code[m+1] = st & 255;
    st >>= 8;
    for (int i = m; i >= 0; i--) {
        code[i] = st & 7;
        st >>= 3;
    }
}

ll encode()
{
    ll st = 0;
    int cnt = 1;
    memset(ch, -1, sizeof(ch));
    ch[0] = 0;
    for (int i = 0; i <= m; i++) {
        if (ch[code[i]] == -1) ch[code[i]] = cnt++;
        code[i] = ch[code[i]];
        st <<= 3;
        st |= code[i];
    }
    st <<= 8;
    st |= code[m+1];
    return st;
}

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

void dp(int r, int c, int cur)
{
    for (int k = 0; k < hm[cur].size; k++) {
        decode(hm[cur].state[k]);
        int up = code[c], left = code[c-1];
        if (!mp[r][c]) {
            if (up || left) continue;
            code[c] = code[c-1] = 0;
            if (c == m) shift();
            hm[cur^1].push(encode(), hm[cur].f[k]);
        }
        else {
            if (up && left) {
                if (up == left) {
                    if (code[m+1]++ >= l) continue;
                    int t = 0;
                    for (int i = 0; i < c-1; i++) {
                        if (code[i]) t++;
                    }
                    if (t&1)continue;
                    code[c] = code[c-1] = 0;
                    if (c == m) shift();
                    hm[cur^1].push(encode(), hm[cur].f[k]);
                }
                else {
                    code[c] = code[c-1] = 0;
                    for (int i = 0; i <= m; i++) {
                        if (code[i] == left) code[i] = up;
                    }
                    if (c == m) shift();
                    hm[cur^1].push(encode(), hm[cur].f[k]);
                }
            }
            else if (up || left) {
                if (mp[r][c+1]) {
                    code[c] = up | left;
                    code[c-1] = 0;
                    // if (c == m) shift();
                    hm[cur^1].push(encode(), hm[cur].f[k]);
                }
                if (mp[r+1][c]) {
                    code[c-1] = up | left;
                    code[c] = 0;
                    if (c == m) shift();
                    hm[cur^1].push(encode(), hm[cur].f[k]);
                }
            }
            else {
                if (mp[r][c+1] && mp[r+1][c]) {
                    code[c] = code[c-1] = 7;
                    if (c == m) shift();
                    hm[cur^1].push(encode(), hm[cur].f[k]);
                }
            }
        }
    }
}

int main()
{
    int test;
    cin >> test;
    while (test--) {
        scanf("%d %d %d", &n, &m, &l);
        char t[100];
        for (int i = 1; i <= n; i++) {
            scanf("%s", t);
            for (int j = 0; j < n; j++) {
                mp[i][j+1] = t[j] == '.';
            }
        }
        int cur = 0;
        hm[cur].init();
        hm[cur].push(0, 1);
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++) {
                hm[cur^1].init();
                dp(i, j, cur);
                cur ^= 1;
            }
        }
        ll ans = 0;
        for (int i = 0; i < hm[cur].size; i++) {
            decode(hm[cur].state[i]);
            if (code[m+1] == l) {
                ans = (ans + hm[cur].f[i]) % mod;
            }
        }
        cout << ans << endl;
    }
    return 0;
}