暑期个人赛--第十一场--D

D. 学妹去搬砖 2014新生暑假个人排位赛09

时间限制 1000 ms 内存限制 65536 KB

题目描述

大家都知道，学校里有很多路在修，修路需要砖块。这一天，Mr.F来到集训队，找学妹去帮忙搬砖块。善良的学长们不忍心让学妹劳动，就争先恐后的帮助学妹搬砖。于是聪明的学妹说，我出一个题，谁答出来谁就能帮我搬砖。
把学校要铺的地面看成是n*m的方格，每一块砖的大小是1*2，学妹想知道有多少种方法可以把这块地铺满。注意地上有可能会有花花草草，有爱心的学妹不忍心砖块把它们压死，所以这些点是不可以铺砖块的。

输入格式

输入多组数据，数据组数不超过20组。每组第一行为三个整数n, m, k，(1<=n, m<=10)，k<=n*m，分别代表地面的长宽，以及花花草草的数量。接下来k行，每行一组x,y，表示花花草草的坐标。详细方向见样例。

输出格式

每组输出一个数，即最后的方案数。由于输出会很大，请输出答案mod 1000000007(10^9+7)。

输入样例

3 1 12 03 1 0

输出样例

10hint:第一组样例所示地面为：..*其中‘.‘表示空地，’*‘表示花花草草，一种方案可以铺满。

赛中提交：AC

思路&反省：

赛中也只是照着模版抄了，算是苟且过了，其实对于过程还不是很理解。

现在看了下wata的白书还有上网搜到了一个不错讲解，

先插一下自己对这个方法的理解：

（1）dpij代表第i行第j列的瓷砖状态，他的值是0或1

（2）遍历时，行为最外层遍历，列为内层遍历

（3）横铺时两格都用1，竖铺时上用0下用1，关于为什么这么设计，

因为如果不管横竖都是1那么还怎么分是横是竖？就不便状态转移。

详见下面转载的讲解：

下列

原帖链接：  http://www.2cto.com/kf/201208/146894.html

这个题目类属于状态压缩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

补充说明一点，当测试循环中，我们有时候必须要移动 1 位，有时候移动2位，当需要移动2位并且 x == M - 1(M列数）的时候，说明已经不可能兼容了。

根据上面的分析就不难写出代码了：[cpp]#include <stdio.h> #include <memory.h> #include <math.h> #include <algorithm> using namespace std;   #define MAX_ROW 11 #define MAX_STATUS 2048 long long DP[MAX_ROW][MAX_STATUS]; int g_Width, g_Height;  bool TestFirstLine(int nStatus)  //test the first line {     int i = 0;      while( i < g_Width)     {         if(nStatus & (0x1 << i))         {             if( i == g_Width -1 || (nStatus & (0x1 << (i+1))) == 0)             {                 return false;             }             i += 2;         }         else         {             i++;         }     }     return true; }  bool CompatablityTest(int nStatusA, int nStatusB) // test if status (i, nStatusA) and (i-1, nStatusB) is compatable. {     int i = 0;      while( i < g_Width)     {         if( (nStatusA & (0x1 << i))  == 0)         {             if((nStatusB & (0x1 << i)) == 0)             {                 return false;             }             i++;         }         else         {             if((nStatusB & (0x1 << i)) == 0 )             {                 i++;             }             else if( (i == g_Width - 1) || ! ( (nStatusA & (0x1 << (i+1))) && (nStatusB & (0x1 << (i + 1)))) )             {                 return false;             }             else             {                 i += 2;             }          }     }     return true; } int main() {     int i,j;     int k;     while(scanf("%d%d", &g_Height, &g_Width) != EOF )     {         if(g_Width == 0 && g_Height == 0)         {             break;         }          if(g_Width > g_Height)         {             swap(g_Width, g_Height);         }           int nAllStatus = 2 << (g_Width-1);         memset(DP, 0, sizeof(DP));         for( j = 0; j < nAllStatus; j++)         {             if(TestFirstLine(j))             {                 DP[0][j] = 1;             }         }          for( i = 1; i < g_Height; i++)         {                 for( j = 0; j < nAllStatus; j++)// iterate all status for line i             {                 for( k = 0; k < nAllStatus; k++) // iterate all status for line i-1                 {                     if(CompatablityTest(j, k))                     {                         DP[i][j] += DP[i-1][k];                     }                 }             }         }         printf("%lld\n", DP[g_Height-1][nAllStatus - 1]);     }     return 0; } 几点注意：因为算法 复杂度是  H * (W^4) 所以当 W > H的时候，我们交换他们这样适当降低复杂度。另外数据到后面比较大，所以使用 long long( __int64) 作者：hopeztm

这是我的ac代码：

#include <iostream>#include <string.h>#include <stdio.h>#include <stdlib.h>#include <math.h>#include <string>#include <vector>#include <list>#include <map>#include <queue>#include <stack>#include <bitset>#include <algorithm>#include <numeric>#include <functional>#define maxn 11#define mod 1000000007 using namespace std;int dp[2][1<<maxn];bool color[maxn][maxn];int n,m,k; void solve(){    int *crt=dp[0],*next=dp[1];    crt[0]=1;    for(int i=n-1;i>=0;i-=1){        for(int j=m-1;j>=0;j-=1){            for(int used=0;used<1<<m;used+=1){                if((used>>j&1)||color[i][j]){                    next[used]=crt[used&~(1<<j)];                }                else{                    int res=0;                    if(j+1<m&&!(used>>(j+1)&1)&&!color[i][j+1]){                        res+=crt[used|1<<(j+1)];                    }                     if(i+1<n&&!color[i+1][j]){                        res+=crt[used|1<<j];                    }                    next[used]=res%mod;                }            }            swap(crt,next);        }    }    printf("%d\n",crt[0]);} int main(){    while(scanf("%d %d %d",&n,&m,&k)!=EOF){        memset(color,false,sizeof(color));        memset(dp,0,sizeof(dp));        for(int i=0;i<k;i+=1){            int x,y;            scanf("%d %d",&x,&y);            color[x][y]=true;        }        solve();    }    return 0;}