POJ 2411 + POJ 2663 + POJ 3420 小方格填充之多米诺骨牌系列(状压DP)

原文链接：http://blog.csdn.net/shiwei408/article/details/8821853

解决此类问题，一般都是用1*2的小方块填充 n*m的矩阵。其中n或m两者中至少有一个较小。

解决此类的方法，当n和m都很小的时候，可以直接for循环枚举状态来更新求值。但是当二者间有一个稍大的时候，就需要构造矩阵来解决此类问题。通常将较小的那个数作为列用dfs来枚举两行之间的状态。

状态标记： 横放和竖放的下一个均为1，竖放的上一个和不放置为0 ，每行可以转化为1个2进制数。当这一行访问结束时，就会得到上一行状态，和该行状态，因为所有情况都是我们设置的，所以pre状态一定会转化为now状态。

对于每一个位置，我们有三种放置方法：1. 竖直放置2. 水平放置3. 不放置。

dfs的时候三个参数分别是 num,now,pre，分别表示当前的列数，当前行的状态，上一行的状态，初始化的时候num=now=pre = 0。每两行之间有三种状态：

1. num = num + 1, now << 1 | 1, pre << 1; // 竖直放置，当前行该列为1，上一行该列置为为0

2. num = num + 2, （now << 2） | 3, （pre<< 2） | 3; // 横放 都为11

3. num = num + 1, now << 1, pre<< 1 | 1; // 上一行该列置为1，不能竖放，不放置的状态

注意不存在上一行当前列不放置，这一行放置的情况。

DFS枚举状态时候的情况：

typedef long long LL;
int n,m,tan;
LL dp[13][1<<11];
LL matrix[11*(1<<12)][2];//注意是 11*（1<<12)
void dfs(int num,int now,int pre)
{
if(num>m) return;
if( num==m )
{
matrix[++tan][0] = pre;
matrix[tan][1] = now;
return;
}
dfs(num+1,(now<<1)|1,pre<<1);
dfs(num+2,(now<<2)|3,(pre<<2)|3);
dfs(num+1,pre<<1,(now<<1)|1);
return;
}

更新答案的时候，最后的总ans就是dp
[(1<< m)-1]的值。

memset(dp,0,sizeof(dp));
dp[0][(1<<m)-1] = 1;
for(int i=1;i<=n;i++)
{
for(int j=1;j<=tan;j++)
{
dp[i][matrix[j][1]] += dp[i-1][matrix[j][0]];
}
}
cout<<dp
[(1<<m)-1]<<endl;

POJ2411，n，m不大于11，小范围可递推，可用矩阵枚举。

#include <iostream>
#include <cstring>
#include <algorithm>
#include <cstdio>
#include <climits>
using namespace std;

typedef long long LL;
int n,m,tan;
LL dp[13][1<<11];
LL matrix[11*(1<<12)][2];
void dfs(int num,int now,int pre)
{
if(num>m) return;
if( num==m )
{
matrix[++tan][0] = pre;
matrix[tan][1] = now;
return;
}
dfs(num+1,(now<<1)|1,pre<<1);
dfs(num+2,(now<<2)|3,(pre<<2)|3);
dfs(num+1,now<<1,(pre<<1)|1);
return;
}
int main()
{
while ( scanf("%d%d",&n,&m)!=EOF && n && m)
{
if( n<m ) swap(n,m);
tan = 0;
dfs(0,0,0);

memset(dp,0,sizeof(dp));
dp[0][(1<<m)-1] = 1;
for(int i=1;i<=n;i++)
{
for(int j=1;j<=tan;j++)
{
dp[i][matrix[j][1]] += dp[i-1][matrix[j][0]];
}
}
cout<<dp
[(1<<m)-1]<<endl;
}
return 0;
}

POJ 26633*12矩阵，代码与上类似，不再赘述。

POJ34201*2的小矩形，去拼接一个4*n（n<10^9）的矩形。N这么大递推肯定是不行了，所以我们要用矩阵快速幂进行加速，这个转移矩阵如何构造呢，我们可以直接用pre状态转移到now状态采用邻接矩阵的方式表述。

#include <iostream>
#include <cstring>
#include <algorithm>
#include <cstdio>
#include <climits>
using namespace std;

typedef long long LL;
int n,mod;
struct mat{
LL at[16][16];
};
mat dat;

void dfs(int num,int now,int pre)
{
if(num>4) return;
if( num==4 )
{
++dat.at[pre][now];
return;
}
dfs(num+1,(now<<1)|1,pre<<1);
dfs(num+2,(now<<2)|3,(pre<<2)|3);
dfs(num+1,now<<1,(pre<<1)|1);
return;
}
mat quick_pow(mat a,mat b)
{
mat tmp; memset(tmp.at,0,sizeof(tmp.at));
for(int i=0;i<16;i++)
{
for(int k=0;k<16;k++)
{
if( a.at[i][k])
for(int j = 0;j<16;j++)
{
tmp.at[i][j] = ( tmp.at[i][j] +(a.at[i][k] * b.at[k][j])%mod) %mod;
}
}
}
return tmp;
}
mat cal(mat a,int k)
{
if(k==1)  return a;
mat tmp; memset(tmp.at,0,sizeof(tmp.at));
for(int i=0;i<16;i++) tmp.at[i][i] = 1;
if(k==0) return tmp;
while(k)
{
if( k&1 )  tmp = quick_pow(a,tmp);
k>>=1;
a = quick_pow( a,a);
}
return tmp;
}
int main()
{
memset(dat.at,0,sizeof(dat.at));
dfs(0,0,0);
while ( scanf("%d%d",&n,&mod)!=EOF && n && mod)
{
if(mod==1) {
cout<<0<<endl;
continue;
}
mat ans = cal(dat,n);
cout<<ans.at[15][15]<<endl;
}
return 0;
}