多米诺牌集
多米诺gu牌覆盖问题也是经典的题目了，主要是由1*k的牌覆盖m*n的矩阵之类的。有递推求解的，也有的如下：
如POJ 2411，由1*2的小矩形去覆盖m*n的矩形，问有多少种方案。
这道题其实只要计算出上下两行之前的可能存在的状态转换，这样就很容易求解了。如下：
void dfs(int pre,int now,int l){//上一行的状态，当前行的状态，当前列的位置
if(l>w) return;
if(l==w){
trans[nt][0]=pre,trans[nt++][1]=now;
return ;
}
dfs(pre<<1,now<<1|1,l+1); //竖着放，则上一行当前为置为空，下一行被覆盖
dfs(pre<<2|3,now<<2|3,l+2);//当前行横着放
dfs(pre<<1|1,now<<1,l+1);//当前行当前位置不放
}
于是，POJ 2411 可以如下解题：
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#define LL __int64
using namespace std;
int nt,h,w;
int trans[11*(1<<11)][2];
LL f[12][1<<11];
void dfs(int pre,int now,int l){
if(l>w) return;
if(l==w){
trans[nt][0]=pre,trans[nt++][1]=now;
return ;
}
dfs(pre<<1,now<<1|1,l+1);
dfs(pre<<2|3,now<<2|3,l+2);
dfs(pre<<1|1,now<<1,l+1);
}
int main(){
while(scanf("%d%d",&h,&w),h||w){
nt=0;
dfs(0,0,0);
memset(f,0,sizeof(f));
f[0][(1<<w)-1]=1;
for(int i=1;i<=h;i++){
for(int j=0;j<nt;j++){
if(f[i-1][trans[j][0]]){
f[i][trans[j][1]]+=f[i-1][trans[j][0]];
}
}
}
printf("%I64d\n",f[h][(1<<w)-1]);
}
return 0;
}
另外如POJ 2663，也是同样的解法。
#include <iostream> #include <cstdio> #include <cstring> #include <algorithm> #define LL __int64 using namespace std; int trans[10*(1<<3)][2]; int nt; //LL dp[2001][20001]; LL f[31][1<<3]; void dfs(int pre,int now,int l){ if(l>3) return ; if(l==3){ trans[nt][0]=pre; trans[nt++][1]=now; return ; } dfs(pre<<1,now<<1|1,l+1); dfs(pre<<2|3,now<<2|3,l+2); dfs(pre<<1|1,now<<1,l+1); } int main(){ int n; nt=0; dfs(0,0,0); while(~scanf("%d",&n)){ if(n==-1) break; memset(f,0,sizeof(f)); f[0][(1<<3)-1]=1; for(int i=1;i<=n;i++){ for(int j=0;j<nt;j++){ if(f[i-1][trans[j][0]]){ f[i][trans[j][1]]+=f[i-1][trans[j][0]]; } } } printf("%I64d\n",f[n][(1<<3)-1]); } return 0; }
POJ 3420.由于n比较大，而且两行之间的状态转换就是不断的重复，可以使用快速矩阵乘法，把状态转换矩阵保存下来，然后快速乘，则结果保存在trans[15][15]的位置。
#include <iostream> #include <cstdio> #include <cstring> using namespace std; struct Matrix{ int trans[1<<4][1<<4]; void init(){ memset(trans,0,sizeof(trans)); } void per(){ memset(trans,0,sizeof(trans)); for(int i=0;i<16;i++) trans[i][i]=1; } }; int M,n; Matrix T; Matrix multi(Matrix a,Matrix b){ Matrix ans; ans.init(); for(int i=0;i<16;i++){ for(int j=0;j<16;j++){ for(int k=0;k<16;k++){ ans.trans[i][j]=(ans.trans[i][j]+(a.trans[i][k]*b.trans[k][j])%M)%M; } } } return ans; } void dfs(int pre,int now,int l){ if(l>4) return ; if(l==4){ T.trans[pre][now]++; return ; } dfs(pre<<1|1,now<<1,l+1); dfs(pre<<2|3,now<<2|3,l+2); dfs(pre<<1,now<<1|1,l+1); } int quick(int n){ Matrix p; p.per(); Matrix sq=T; while(n){ if(n&1) p=multi(sq,p); sq=multi(sq,sq); n>>=1; } return p.trans[15][15]; } int main(){ T.init(); dfs(0,0,0); while(scanf("%d%d",&n,&M),n||M){ printf("%d\n",quick(n)); } return 0; }
HDU 5100
问以1*k的小矩阵覆盖n*n的大矩形，最多能覆盖的面积。
对于n%k==0的情况就不用说了，对于不整除的，可以直观的发现，不覆盖的情况必定是个正方形，其边长要么是n%k或者k-n%k。其实这个是可以证明的，
转自http://www.matrix67.com/blog/archives/5900。。。。。。我没有侵权啊。。。T_T
用 k × 1 的小矩形覆盖一个 n × n 的正方形棋盘，往往不能实现完全覆盖（比如，有时候 n × n 甚至根本就不是 k 的整倍数）。不过，在众多覆盖方案中，总有一种覆盖方案会让没有覆盖到的方格个数达到最少，我们就用 m(n, k) 来表示这个数目。求证：不管 n 和 k 是多少， m(n, k) 一定是一个完全平方数。
如果 n < k ，那么很明显，棋盘里一个小矩形也放不下，因而 m(n, k) = n2 ，这是一个完全平方数。下面我们就只考虑 n ≥ k 了。
我们先来证明这样一个事实：如果某个覆盖方案当中，仅剩下一个 s × s 的小正方形区域没有覆盖到，其中 s ≤ k / 2 ，那么这样的方案一定是最优的。首先，在棋盘中的每个格子里都填上一个数，使得从最左下角出发，各个对角线上的数依次为 0, 1, 2, …, k – 1, 0, 1, 2, …, k – 1, … （上图所示的是 k = 6 的情况）。那么，把一个 k × 1 的小矩形放在棋盘中的任意位置，它总会覆盖每种数字各一个。假设某个覆盖方案当中，仅剩下一个 s × s 的小正方形区域没有覆盖到。注意到，任意一个 s × s 的小正方形区域里最多只会出现 2s – 1 种不同的数，因此如果 s ≤ k / 2 ，那么这个 s × s 的小正方形区域里一定会缺失至少一种数，比方说 x （在上图中，右上角的那个 3 × 3 的空白区域里就缺数字 5 ，因而我们可以取 x = 5 ）。由此可以推出，此时小矩形的数目已经达到了最大值，任何其他覆盖方案都不可能包含更多的小矩形，因为每个小矩形都必然会覆盖到一个 x ，然而在刚才的覆盖方案中，所有的 x 都已经被覆盖到了。
有趣的是，当 n ≥ k 时，让整个棋盘仅剩一个边长不超过 k / 2 的小正方形区域没有覆盖到，这是一定能做到的。不妨把 n 除以 k 的余数记作 r 。如果 r ≤ k / 2 ，那么我们可以直接用横着的小矩形从左向右填充棋盘，再用竖着的小矩形填充余下的部分，最终会剩下 r × r 的小正方形区域。上图所示的就是 n = 22 并且 k = 5 的情况，注意到 22 除以 5 的余数为 2 ，确实小于等于除数 5 的一半。可见，对于这类情况，我们都有 m(n, k) = r2 ，这是一个完全平方数。
如果 r > k / 2 呢？我们可以用和刚才类似的方法填充棋盘，使得棋盘右上角仅剩一个 (r + k) × (r + k) 的正方形区域。然后再用 4r 个小矩形像风车一样填充这个 (r + k) × (r + k) 的区域，使得正中间只剩下一个边长为 k – r 的小正方形区域。由于 k – r < k / 2 ，因而此时的覆盖方案再次达到最优。上图所示的就是 n = 22 并且 k = 6 的情况，注意到 22 除以 6 的余数为 4 ，确实大于除数 6 的一半。可见，对于这类情况，我们有 m(n, k) = (k – r)2 ，这仍然是一个完全平方数。
HDU 5100
#include <iostream> #include <cstdio> #include <cstring> #include <algorithm> using namespace std; int main(){ int n,k,T; scanf("%d",&T); while(T--){ scanf("%d%d",&n,&k); if(k>n){ puts("0"); continue; } if(n%k==0) printf("%d\n",n*n); else{ int l=min(n%k,k-n%k); printf("%d\n",n*n-l*l); } } return 0; }
