HDU 4064 Carcassonne（插头DP）（The 36th ACM/ICPC Asia Regional Fuzhou Site —— Online Contest）

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=4064

Problem Description

Carcassonne is a tile-based board game for two to five players.
Square tiles are printed by city segments,road segments and field segments. 

The rule of the game is to put the tiles alternately. Two tiles share one edge should exactly connect to each other, that is, city segments should be linked to city segments, road to road, and field to field. 

To simplify the problem, we only consider putting tiles:
Given n*m tiles. You can rotate each tile, but not flip top to bottom, and not change their order. 
How many ways could you rotate them to make them follow the rules mentioned above?

 

Input

The first line is a number T(1<=T<=50), represents the number of case. The next T blocks follow each indicates a case.
Each case starts with two number N,M(0<N,M<=12)
Then N*M lines follow,each line contains M four-character clockwise.
'C' indicate City.
'R' indicate Road.
'F' indicate Field.

 

Output

For each case, output the number of ways mod 1,000,000,007.(as shown in the sample output)

 

题目大意：给一个n*m的矩阵，每个格子有一个方块，给出方块顺时针方向的每条边颜色，方块可以旋转，要求相邻的边颜色相同，问有多少种方案。

思路：以颜色做状态，3种颜色，用4进制。就是一个普通的插头DP，好长时间没写插头DP了结果调了半天T_T。

 

代码（15MS）：

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
using namespace std;
typedef long long LL;

const int MAXN = 13;
const int SIZE = 1000007;
const int MOD = 1e9 + 7;

struct Hashmap {
    int head[SIZE], ecnt;
    int to[SIZE], next[SIZE], val[SIZE];
    int stk[SIZE], top;

    Hashmap() {
        memset(head, -1, sizeof(head));
    }

    void clear() {
        while(top) head[stk[--top]] = -1;
        ecnt = 0;
        //for(int i = 0; i < SIZE; ++i) if(head[i] != -1) cout<<"error"<<endl;
    }

    void insert(int st, int value) {
        int h = st % SIZE;
        for(int p = head[h]; ~p; p = next[p]) {
            if(to[p] == st) {
                val[p] += value;
                if(val[p] >= MOD) val[p] -= MOD;
                return ;
            }
        }
        if(head[h] == -1) stk[top++] = h;
        to[ecnt] = st; val[ecnt] = value; next[ecnt] = head[h]; head[h] = ecnt++;
    }
} hashmap[2], *pre, *cur;

char s[MAXN][MAXN][5];
int w[128];
int n, m, T;

int getState(int state, int i) {
    return (state >> (i << 1)) & 3;
}

void setState(int &state, int i, int val) {
    i <<= 1;
    state = (state & ~(3 << i)) | (val << i);
}

int solve() {
    pre = &hashmap[0], cur = &hashmap[1];
    cur->clear();
    cur->insert(0, 1);
    int maxState = (1 << ((m + 1) << 1)) - 1;
    for(int i = 0; i < n; ++i) {
        for(int p = 0; p < cur->ecnt; ++p)
            cur->to[p] = (cur->to[p] << 2) & maxState;
        for(int j = 0; j < m; ++j) {
            swap(pre, cur);
            cur->clear();
            for(int p = 0; p < pre->ecnt; ++p) {
                int st = pre->to[p];
                for(int k = 0; k < 4; ++k) {
                    if(j != 0 && w[(int)s[i][j][(k + 1) & 3]] != getState(st, j)) continue;
                    if(i != 0 && w[(int)s[i][j][(k + 2) & 3]] != getState(st, j + 1)) continue;
                    int new_st = st;
                    setState(new_st, j, w[(int)s[i][j][k]]);
                    setState(new_st, j + 1, w[(int)s[i][j][(k + 3) & 3]]);
                    cur->insert(new_st, pre->val[p]);
                }
            }
        }
    }
    int res = 0;
    for(int p = 0; p < cur->ecnt; ++p) {
        res += cur->val[p];
        if(res >= MOD) res -= MOD;
    }
    return res;
}

int main() {
    w['F'] = 0; w['C'] = 1; w['R'] = 2;
    scanf("%d", &T);
    for(int t = 1; t <= T; ++t) {
        scanf("%d%d", &n, &m);
        for(int i = 0; i < n; ++i)
            for(int j = 0; j < m; ++j) scanf("%s", s[i][j]);
        printf("Case %d: %d\n", t, solve());
    }
}