状态压缩 【POJ2411】Mondriaan'sDream

【题目大意】一个矩阵，只能放1*2的木块，问将这个矩阵完全覆盖的不同放法有多少种。

【解析】如果是横着的就定义11，如果竖着的定义为竖着的01，这样按行dp只需要考虑两件事儿，当前行&上一行，是不是全为1，不是说明竖着有空（不可能出现竖着的00），另一个要检查当前行里有没有横放的，但为奇数的1。

【状态表示】dp[state][i]第i行状态为state时候的方案数 

【转移方程】dp[state][i] += dp[state'][i-1] state'为i-1行的，不与i行状态state冲突的状态

【边界条件】第一行 符合条件的状态记为1 即dp[state][0] = 1;

这个题目类属于状态压缩DP，对于状态压缩DP，其实最简单的理解就是把状态用比特位的形式表示出来，我们会在下面用例子来说明。

假如现在我们在铺砖 位置(i, j), 并且假设之前的位置已经铺设好的了，在这个位置，我们的选择：

1. 不用铺砖了，可能在(i-1, j)的时刻已经被竖着铺上了，然后考虑的是（i， j+1）
2. 横铺砖，将(i, j+1）也铺上了，然后考虑的是(i, j+2)

3. 竖着铺砖，（将i，j）和（i+1，j）铺上一个竖立的转头。

所以我们如下翻译我们的选择，在位置(i, j) 如果我们选择横着贴砖，那么将(i, j), (i, j+1)都填写成1， 如果竖着贴砖，我们将(i,j)填写成0， 将(i+1, j)填写成1.

为什么要这么计数呢，我觉得应该这样理解：

1. 在横着贴砖的时候，(i, j), (i, j+1) 都是1，这个值其实对下一行如何选择没有影响。

2. 竖着贴砖的第二个，我们也选择了1， 因为这个砖头结束了，对下一行如何选择依然没有影响。

3. 而竖着的第一个砖头，这个砖头是对下面有影响的，如果(i,j)是0，那么(i+1, j)只有是1的情况下才能满足条件。

（这涉及到接下来的 状态兼容性问题）

对于竖着贴砖为什么这样选择，这样选择的一个好处是，我们在处理最后一行的时候，可以保证最后一行都是1， 因为最后一行绝对不能成为 竖砖开始，所以很容易取得最后的解。

好了，我们把这样理解的方案画成图：

 

如果我们将每一行都理解成一个二进制数字，那么

Row1 = 51,  Row2 = 15, Row3 = 48, Row4 = 63, Row5 = 51, Row6 = 63.

最后转头铺满的状态，一定是最后一行全是1。

我们用DP(i,j) 表示如下含义： 当第i行，达到状态j的时候，所能采取的方案数目。 所以明显我们的最后目的是求 DP(N, 2^(M-1)-1);

我们再来简单的分析一下为什么问题可以满足动态规划， 加入现在分析的对象是 DP(i,j)， 那么这一行有多少种铺设办法是和上一行相关的，

如果上一行的某个状态DP(i-1,k) 可以达到 DP(i, j) 我们认为这两个状态是兼容的，如果DP(i-1,k)和DP(i, j)兼容并且 DP(i-1, k)有S中铺设方案，那么DP(i, j)就可以从DP(i-1, k)

这条路径中获得S个方案。 当然这里k的取值可以是 0 ~~~~ 2^(M-1) -1种取值。

现在我们来理解一下，什么叫做 j, k 兼容。

其实我们在上面已经基本给出分析， 如果我们现在铺设 (i,x) x这里表示第i行，第x列

1. 如果值 i  行，j 在x位上的值是0， 那么第 i-1行，j的值在x位上一定是1。因为不可能在同一列相邻的位置铺两个竖着的 第一个，如果满足下一步测试的是(i, x+1), 否则直接返回不兼容。

2. 如果值 i  行，j在x位置的值是1 .

{

            那么有可能有两种情况：

            1. (i-1, x)是0， 这个时候一定是竖着铺设了，下一步检测的是(i, x + 1)

           

            2.  (i-1, x) 是1， 如果是这样的话，那么(i, x)一定是要选择横着铺了，那么(i,x+1)也一定是1，并且(i-1, x + 1)一定是1（如果是0，就是竖着铺了），如果不满足就返回不兼容，满足条件 就测试(i, x + 2)

              

}

对于第一行的兼容性，我们要做一下特别的分析，在第一行中，要么放0， 要么放1。

加入当前测试的是 DP(0, j)的第 x的比特位，即第0行，x列

1. 如果x是1，那么 x + 1 也一定是1，然后测试到 x + 2

2. 如果x是0， 那么直接测试下一个 x + 1

代码：

#include <cstdio>
 
#include <cstring>
 
using namespace std;
 
int M,N;
 
long long dp[1<<11][11];
 
bool kexing[1<<11];
 
int full;
 
inline bool check(int in)
 
{
 
        int bit=0;
 
        while(in>0){
 
                if( (in&1)==1)
 
                         bit++;
 
                else{
 
                         if( (bit&1)==1)
 
                                  return false;
 
                         bit=0;
 
                }
 
                in>>=1;
 
        }
 
        if( (bit&1)==1)
 
                return false;
 
        return true;
 
}
 
inline bool check2(int x1,int x2){
 
   if( (x1|x2)!= full-1 )  //如果这里不用位运算，时间很长，要用约3000MS
 
                return false;
 
    return kexing[x1&x2];
 
}
 
int main(){
 
     full = 1<<11;
 
    for(int s = 0; s < full; ++s)if(check(s))kexing[s] = 1;
 
    while(scanf("%d%d",&M,&N) != EOF){
 
        if(N == 0 && M == 0)break;
 
        memset(dp,0,sizeof(dp));
 
        full = 1<<N;
 
        for(int s = 0; s < full; ++s){
 
            if(kexing[s])
 
                dp[s][0] = 1;
 
        }
 
        for(int i = 1; i < M; ++i){
 
            for(int s = 0; s < full; ++s){
 
                for(int s1 = 0; s1 < full; ++s1){
 
                    if(!check2(s1,s))continue;
 
                    //if(dp[s1][i-1] == 0)continue;  
 
                    /*这一步判断的时间要大于位运算和+=的时间，如果先把这一步放在
 
                    check2前面，1300多MS，如果放在check2后面，610多MS，如果不加这
 
                    一步，560MS，但如果check2用的不是位运算，将这一步加在check2前
 
                    面3000MS左右（水过），如果不加这一步，TLE
 
                    */
 
                    dp[s][i] += dp[s1][i-1];
 
                }
 
            }
 
        }
 
        int S = (1<<N) - 1;
 
        printf("%lld\n",dp[S][M-1]);
 
    }
 
    return 0;
 
}