題目大意：有一個由n*m組成的地磚，現在拿1*2的地磚來鋪，要求必須鋪滿。求總方案數(n,m<=11)。

這是一道狀壓Dp和插頭Dp的經典題目。不過，或許很多人和我一樣，看到這種題目後，都會想到搜尋。可是搜尋的時間複雜度是O(2^nm)，肯定超時了。

【解法一：狀壓Dp】

首先設f[i][j]為前i行且第i行狀態為j時的方案總數。那麼f[i][j] = sum(f[i-1][j'] | j'能到達j)；反過來，對於f[i][j]，它可以向f[i+1][j'']貢獻（其中j能到達j‘’）。

那樣就可以設鋪的為1，不鋪的為0。拿1*2的地磚來鋪，無非就是橫鋪或者豎鋪。顯然：如果第i行的第k位不鋪，又由於必須鋪滿，所以第i+1行的第k為必須鋪。也就是說，如果把狀態j取反，二進位制中為1的那一個位置就必須豎著鋪。

所以，對於每一行的狀態j，可以用DFS來算出j能到達的狀態，則這個演算法的時間複雜度為O(n*2^2m)。

小優化：若n和m都是奇數，則答案為0。

證明：因為 n,m為奇數，

         不妨設：n=2q-1,m=2p-1(q,p為正整數)，

           所以：nm=(2q-1)(2p-1) = 4qp - 2q - 2p + 1

           又因為：4qp,2q,2p為偶數，

           所以：nm為奇數。

因為是拿1*2的地磚鋪，且必須鋪滿。

所以nm是偶數，矛盾，正畢。

附上程式碼：

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cstring>

using namespace std;
#define Maxn 14

int sta[1<<Maxn];
long long f[Maxn][1<<Maxn];
int n,m,fp,p;

void dfs(int num,int p)
{
	if(p+1==m)
	{
		sta[fp++] = num;
		return;
	}
	dfs(num,p+1);//不鋪 
	
	if((num&(1<<p)) || (num&(1<<(p+1)))) return;
	dfs(num|(3<<p),p+1);//橫著鋪 
}

int main()
{
	while(scanf("%d%d",&n,&m) && n && m)
	{
		memset(f,0,sizeof(f));
		if(n*m%2)//小優化 
		{
			printf("0\n");
			continue;
		}
		fp=0;
		dfs(0,0);//預處理第一行 
		for(int i=0;i<fp;i++)
			f[1][sta[i]] = 1;
		
		p = 1<<m;
		for(int i=1;i<n;i++)
		for(int j=0;j<p;j++)//列舉當前狀態j 
		{
			fp = 0;
			dfs(p-1-j,0);
			for(int k=0;k<fp;k++)//列舉j能到達的狀態 
				f[i+1][sta[k]] += f[i][j]; 
		}
		cout<<f[n][p-1]<<endl;
	}
	return 0;
}
 

【解法二：插頭Dp】：

設f[i][j][k]表示當前列舉到第i行第j列的地磚，且前面m個地磚（不包括(i,j)）的狀態為k（k用二進位制表示，1表示有，0表示沒有）。則有三種情況。

（1）：不放，當且僅當k的第m位為1，才可以轉移狀態；

（2）：往左放，當k的第m位為1，k的第1位為0且j不在最左時，可轉移；

（3）：往上放，當k的第m位為1且i不在最上面的一行時，轉移；

我們可以根據上面的特點，用二進位制表示出來。

因為每一個(i,j)只和上一次有關，則可以用滾動陣列優化空間。

時間複雜度O(nm*2^m)。

程式：

#include <cstdio>
#include <iostream>
#include <cstring>
#include <algorithm>
#include <cmath>
using namespace std;
#define Maxn 14

long long f[2][1<<Maxn];//注意long long 
int n,m,p,cur;

void change(int x,int y)//狀態轉移 
{
	if(y & (1<<m))
	f[cur][y^(1<<m)] += f[cur^1][x];
}

int main()
{
	while(scanf("%d%d",&n,&m) && n && m)
	{
		if(n*m%2)
		{
			printf("0\n");
			continue;
		}
		if(n<m) swap(n,m);//小優化 
		memset(f,0,sizeof(f));
		
		int p = 1<<m;
		f[cur=0][p-1] = 1;
		
		for(int i=0;i<n;i++)
		for(int j=0;j<m;j++)
		{
			cur^=1;
			memset(f[cur],0,sizeof(f[cur]));
			for(int k=0;k<p;k++)
			{
				change(k,k<<1);//不放 （第k位一定為1）
				if(i && !(k&1<<m-1)) change(k,(k<<1) ^ (1<<m) ^ 1);
 

         //往上放 （注意到“1<<m”，滿足第k位一定為0，才是合法的，因為change函式進行轉移時必須滿足"y&(1<<m)"，然後y|(1<<m)可以去掉它）
				if(j && !(k&1)) change(k,(k<<1)^3);//往左放
			}
		}
		printf("%lld\n",f[cur][p-1]);
	}
	return 0;
}