【动态规划】Formula 1

Background
Regardless of the fact, that Vologda could not get rights to hold the Winter Olympic games of 20**,
it is well-known, that the city will conduct one of the Formula 1 events. Surely, for such an important
thing a new race circuit should be built as well as hotels, restaurants, international airport -
everything for Formula 1 fans, who will flood the city soon. But when all the hotels and a half of
the restaurants were built, it appeared, that at the site for the future circuit a lot of gophers
lived in their holes. Since we like animals very much, ecologists will never allow to build the race
circuit over the holes. So now the mayor is sitting sadly in his office and looking at the map of the
circuit with all the holes plotted on it.

Problem
Who will be smart enough to draw a plan of the circuit and keep the city from inevitable disgrace? Of
course, only true professionals - battle-hardened programmers from the first team of local technical
university!.. But our heroes were not looking for easy life and set much more difficult problem:
"Certainly, our mayor will be glad, if we find how many ways of building the circuit are there!" -
they said.
It should be said, that the circuit in Vologda is going to be rather simple. It will be a rectangle
N*M cells in size with a single circuit segment built through each cell. Each segment should be
parallel to one of rectangle's sides, so only right-angled bends may be on the circuit. At the
picture below two samples are given for N = M = 4 (gray squares mean gopher holes, and the bold
black line means the race circuit). There are no other ways to build the circuit here.

Input
The first line contains the integer numbers N and M (2 ≤ N, M ≤ 12). Each of the next N lines
contains M characters, which are the corresponding cells of the rectangle. Character "." (full
stop) means a cell, where a segment of the race circuit should be built, and character "*"
(asterisk) - a cell, where a gopher hole is located.

Output
You should output the desired number of ways. It is guaranteed, that it does not exceed 263-1.

Sample Input 1:
4 4
**..
....
....
....

Sample Output 1:
2

Sample Input 2:
4 4
....
....
....
....

Sample Output 2:
6

此题考察基于连通性的状态压缩型动态规划。

用括号表示法，具体细节见程序注释。

Accode：

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

typedef long long int64;
const char fi[] = "ural1519.in";
const char fo[] = "ural1519.out";
const int maxN = 20;
const int HOMD = 0xffff;
const int cntSTATUS = 100000;

struct Node
{
    int S, ID;
    Node *next;
};

Node tmp[cntSTATUS];
Node *Hash[HOMD + 1];
int64 f[2][cntSTATUS];
int status[2][cntSTATUS];
int cnt[2];
bool mp[maxN][maxN];
int n, m, pst, ths = 1;

void init_file()
{
    freopen(fi, "r", stdin);
    freopen(fo, "w", stdout);
    return;
}

void readdata()
{
    scanf("%d%d", &n, &m);
    for (int i = 0; i < n; ++i)
    {
        scanf("\n");
        for (int j = 0; j < m; ++j)
            mp[i][j] = (getchar() == '.');
    }
    return;
}

void Clear()
{
    cnt[ths] = 0;
    memset(Hash, 0, sizeof(Hash));
    return;
}

int get_ID(const int S)
{
    unsigned h = S & HOMD;
    for (Node *p = Hash[h]; p; p = p -> next)
        if (p -> S == S) return p -> ID;
    int ID = cnt[ths];
    tmp[ID].S = S;
    tmp[ID].ID = ID;
    tmp[ID].next = Hash[h];
    Hash[h] = &tmp[ID];
    f[ths][ID] = 0;
    status[ths][ID] = S;
    return cnt[ths]++;
}

int get_brac(int S, int pos, int delta)
{
    int tmp = 0;
    for (int t = pos; t >= 0
    && t <= (m << 1); t += delta)
    {
        int Now = (S >> t) & 3;
        if (Now == 1) ++tmp;
        if (Now == 2) --tmp;
        if (!tmp) return t;
    }
}

void work()
{
    Clear();
    f[ths][get_ID(0)] = 1;
    for (int i = 0; i < n; ++i)
    for (int j = 0; j < m; ++j)
    {
        std::swap(pst, ths);
        Clear();
        int p = (m - j) << 1;
        int q = p - 2;
        for (int k = 0; k < cnt[pst]; ++k)
        {
            int64 val = f[pst][k];
            int Last = status[pst][k];
            if (!j) if (Last & 3) continue;
            else Last >>= 2;
            int wp = (Last >> p) & 3, wq = (Last >> q) & 3;
            int Now = Last - (wp << p) - (wq << q);
            if (!mp[i][j])
            {
                if (!wp && !wq) f[ths][get_ID(Now)] += val;
                continue;
            }
	//这里必须先判断障碍格子。
            if (!wp && !wq)
                f[ths][get_ID(Now | (1 << p)
                       | (2 << q))] += val;
            else if (!wp || !wq)
            {
                f[ths][get_ID(Now | (wq << p)
                              | (wp << q))] += val;
                f[ths][get_ID(Now | (wp << p)
                              | (wq << q))] += val;
            }
            else if (wp == 1 && wq == 1)
            {
                f[ths][get_ID(Now ^ (3 <<
                       get_brac(Last, q, -2)))] += val;
            }
            else if (wp == 1 && wq == 2)
            {
                bool flag = true;
                for (int j1 = j + 1; j1 < m; ++j1)
                if (mp[i][j1])
                {
                    flag = false;
                    break;
                }
                for (int i1 = i + 1; i1 < n; ++i1)
                for (int j1 = 0; j1 < m; ++j1)
                if (mp[i1][j1])
                {
                    flag = false;
                    break;
                }
                if (flag) f[ths][get_ID(Now)] += val;
	    }
	//这里必须是整个棋盘中最后一个非障碍格。
            else if (wp == 2 && wq == 1)
                f[ths][get_ID(Now)] += val;
            else if (wp == 2 && wq == 2)
                f[ths][get_ID(Now ^ (3 <<
                       get_brac(Last, p, 2)))] += val;
        }
    }
    int64 ans = f[ths][get_ID(0)];
    int64 outMOD = 1000000000LL;
    if (ans < outMOD) printf("%d", ans);
    else printf("%d%09d",
                (int)(ans / outMOD),
                (int)(ans % outMOD));
	//这里必须强制转换类型，否则出错。
    return;
}

int main()
{
    init_file();
    readdata();
    work();
    return 0;
}