★【动态规划】【状态压缩】【容斥原理】【ZJOI2009】多米诺骨牌

Description
　　有一个n×m的矩形表格，其中有一些位置有障碍。现在要在这个表格内放一些1×2或者2×1的多米诺骨牌，使得任何两个多米诺骨牌没有重叠部分，任何一个骨牌不能放到障碍上。并且满足任何相邻两行之间都有至少一个骨牌横跨，任何相邻两列之间也都至少有一个骨牌横跨。求有多少种不同的放置方法，注意你并不需要放满所有没有障碍的格子。

Input
　　第一行两个整数n;m。接下来n 行，每行m 个字符，表示这个矩形表格。其中字符“x” 表示这个位置有障碍，字符“.” 表示没有障碍。

Output
　　一行一个整数，表示不同的放置方法数mod 19901013 的值。

Sample Input
3 3
...
...
...

Sample Output
2

Hint
两种放置方法分别为
112 411
4.2 4.2
433 332
注意这里的数字只用于区分骨牌，不同的排列并不代表不同的方案。

【数据范围】
对于40% 的数据，满足1 ≤ n;m ≤ 8。
对于90% 的数据，满足1 ≤ n;m ≤ 14。
对于100% 的数据，满足1 ≤ n;m ≤ 15。 

被这道题虐了一上午……

首先考虑一个更简单一些的情况：
若没有“任何相邻两行、列之间都至少有一个骨牌横跨”的限制，那么问题就相当简单了（直接一个裸的状压DP就好了）；
若只有行（任意两行之间）的跨立没有列的跨立，当然也很简单（用插头DP实现，保证每行结束都至少有一个插头指向下一行）。

再回到原问题中。
一种想法就是增加状态的信息，在转移的时候将相邻各列的相连情况记录下来，解决了列的横跨问题；并且用上面所说的方法解决行的横跨问题。（下面附代码。）这样做的复杂度是O(n·m·4^m)，显然要超时。
所以需要继续寻找其他办法。
通常，我们很容易计算某两行（列）之间一定没有骨牌横跨的情况（只需把原问题分解为几个小的部分再把分别的结果相乘即可），所以这令人想到了容斥原理！

首先一个预处理（用状压DP实现），算出ini[U][D][L][R]即在U <= i < D, L <= j < R的矩形中随便放骨牌的总数。
接下来再使用容斥原理计算最终结果。
我们先只考虑列，就拿样例来说：设|A|={1, 2列中有骨牌横跨的情况的总数}，|B|={2, 3列中有骨牌横跨的情况的总数}。
则有：

那么，我们就可以枚举中间的分割线（即规定某些列不能被横跨），对于每一个容斥项（我们暂时把容斥原理公式中的每一项成为容斥项），又在行上进行动态规划（用一个g数组，令g[i]为这个容斥项中的前i行中每相邻两行都有骨牌横跨的总数），最后将结果正负交错地累加起来即可。
Accode：

#include <cstdio>
#include <cstdlib>
#define Add(a, b) ((a) += (b)) %= MOD

typedef long long int64;
const int maxN = 20, MOD = 19901013;
const int maxSTATUS = 1 << 16;

int64 g[maxN], ans, tmp;
char mp[maxN][maxN];
int f[maxN][maxN][maxSTATUS];
int ini[maxN][maxN][maxN][maxN], c[maxN];
int n, m, pst, ths;
int (*f0)[maxSTATUS], (*f1)[maxSTATUS];

int main()
{
    freopen("domino.in", "r", stdin);
    freopen("domino.out", "w", stdout);
    scanf("%d%d\n", &n, &m);
    for (int i = 0; i < n; ++i) gets(mp[i]);
    for (int L = 0; L < m; ++L)
    for (int R = L + 1; R < m + 1; ++R)
    for (int U = 0; U < n; ++U)
    {
        int Lim = 1 << (R - L);
        for (int k = 1; k < Lim; ++k) f[U][L][k] = 0;
        f[U][L][0] = 1;
        for (int i = U; i < n; ++i)
        {
            for (int j = L; j < R; ++j)
            {
                f0 = &f[i][j];
                if (j < R - 1) f1 = &f[i][j + 1];
                else f1 = &f[i + 1][L];
                for (int k = 0; k < Lim; ++k) (*f1)[k] = 0;
                int x = R - j - 1;
                if (mp[i][j] == 'x')
                for (int k = 0; k < Lim; ++k)
                    Add((*f1)[k & ~(1 << x)], (*f0)[k]);
                else for (int k = 0; k < Lim; ++k)
                {
                    if (!((*f0)[k])) continue;
                    Add((*f1)[k & ~(1 << x)], (*f0)[k]);
                    if (j > L && mp[i][j - 1] - 'x'
                        && !(k & (2 << x)))
                        Add((*f1)[k | (3 << x)], (*f0)[k]);
                    if (i > U && mp[i - 1][j] - 'x'
                        && !(k & (1 << x)))
                        Add((*f1)[k | (1 << x)], (*f0)[k]);
                }
            }
            for (int k = 0; k < Lim; ++k)
                Add(ini[U][i + 1][L][R], (*f1)[k]);
        }
    }
    for (int S = 0; S < 1 << (m - 1); ++S)
    {
        int tot = 0; c[tot++] = 0;
        for (int i = 0; i < m - 1; ++i)
            if (S & (1 << i)) c[tot++] = i + 1;
        c[tot] = m;
        for (int D = 1; D < n + 1; ++D)
        for (int U = 0; U < D; ++U)
        {
            tmp = ini[U][D][c[0]][c[1]];
            for (int i = 1; i < tot; ++i)
                (tmp *= ini[U][D][c[i]][c[i + 1]]) %= MOD;
	//这里千万不能用减法代替除法取余，
	//否则后果自负（在时限1000s的情况下都能超时）。
            if (!U) g[D - 1] = tmp;
            else Add(g[D - 1], -tmp * g[U - 1]);
        }
        tmp = (tot & 1) ? g[n - 1] : -g[n - 1];
        Add(ans, tmp);
    }
    printf("%I64d\n", (ans + MOD) % MOD);
    return 0;
}

#undef Add

再贴一个朴素的状压代码：

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

using std::map; using std::make_pair;
const char fi[] = "domino.in";
const char fo[] = "domino_simple.out";
const int maxN = 20, MOD = 19901013;

map <int, int> pst, ths;
map <int, int>::iterator iter;
char mp[maxN][maxN];
int n, m;

inline void Add(int status, int &val)
{
    if (ths.find(status) == ths.end())
    {ths.insert(make_pair(status, val)); return;}
    int &tmp = ths[status];
    if ((tmp += val) >= MOD) tmp -= MOD;
    return;
}

int main()
{
    freopen(fi, "r", stdin);
    freopen(fo, "w", stdout);
    scanf("%d%d\n", &n, &m);
    for (int i = 0; i < n; ++i) gets(mp[i]);
    if (n < 3 || m < 3) {printf("0\n"); return 0;}
    for (int i = 0; i < n - 1; ++i)
    {
        bool flag = 1;
        for (int j = 0; j < m; ++j)
            flag &= (mp[i][j] == 'x' || mp[i + 1][j] == 'x');
        if (flag) {printf("0\n"); return 0;}
    }
    for (int j = 0; j < m - 1; ++j)
    {
        bool flag = 1;
        for (int i = 0; i < n; ++i)
            flag &= (mp[i][j] == 'x' || mp[i][j + 1] == 'x');
        if (flag) {printf("0\n"); return 0;}
    }
    ths.insert(make_pair(0, 1));
    for (int i = 0; i < n; ++i) for (int j = 0; j < m; ++j)
    {
        std::swap(pst, ths); ths.clear();
        int x = m - j - 1;
        for (iter = pst.begin(); iter != pst.end(); ++iter)
        {
            int val = iter -> second, Last = iter -> first;
            if (!val) continue;
            if (!j)
            {
                if (Last & 1) continue;
                else
                {
                    int tmp = Last & (((1 << m - 1) - 1) << m + 1);
                    ((Last &= (1 << m + 1) - 1) >>= 1) |= tmp;
                }
                if (i && !(Last & ((1 << m) - 1))) continue;
            }
            int wx = (Last >> x) & 3, Now = Last - (wx << x);
            if (mp[i][j] == 'x')
            {if (!wx) Add(Now, val); continue;}
            if (wx < 3) Add(Now, val);
            if (!wx)
            {
                if (j < m - 1 && mp[i][j + 1] - 'x')
                    Add(Now | (1 << x) | (1 << x + m), val);
                if (i < n - 1 && mp[i + 1][j] - 'x')
                    Add(Now | (2 << x), val);
            }
        }
    }
    if (ths.find(((1 << m - 1) - 1) << m + 1) == ths.end())
        printf("0\n");
    else printf("%d\n", ths[((1 << m - 1) - 1) << m + 1]);
    return 0;
}