Covering(HDU 6185)（矩阵快速幂）

题目链接：Problem - 6185 (hdu.edu.cn)

题意：

给定一个4*n大小的矩形，将1*2或2*1的矩形往里面填，有多少种能填满的方法

思路：

可以看到n很大，肯定不能dp求解。

后一个状态明显可以由前一个状态推出来，所以这题思路应该是求递推式然后用矩阵快速幂加速求解。

dfs暴力打表看一下1到14的答案有什么规律：

想规律的时候可以从题目的一些小提示入手，题目给的行固定是4，可以想到递推式应该从4之后才满足某种规律，纸上比划一下就可以发现f[n] = f[n-1] + f[n-2]*5 + f[n-3] - f[n-4]

因此直接矩阵快速幂就好了,有个细节需要注意的是f[n]取模之后再减去f[n-4]可能为负数，所以答案要变为正数才行,还有矩阵构造的一些细节在代码注释上。

打表代码：
 

#include <iostream>
using namespace std;
#define MOD 1000000007
const int N = 100;
bool st[N][N]; // st[x][y]表示这个地方是否被填过
int n, m;
int res;
void dfs(int x, int y, int cnt) // 当前坐标x y 和已经填的方块数量
{
    if (y == m + 1)
    {
        y = 1;
        x++;
    }
    if (x == n && y == m) // 走到底了
    {
        if (cnt == n * m / 2) // 最后填的方块数量要等于n * m / 2才是一个合法方案
            res++;
        return;
    }
    if (st[x][y] == false) // 如果没有被填过，看看能不能填
    {
        if (y + 1 <= m && st[x][y + 1] == false) // 能填1*2的方块
        {
            st[x][y] = true;
            st[x][y + 1] = true;
            dfs(x, y + 1, cnt + 1);
            st[x][y] = false;
            st[x][y + 1] = false;
        }
        if (x + 1 <= n && st[x + 1][y] == false) // 能填2*1的方块
        {
            st[x][y] = true;
            st[x + 1][y] = true;
            dfs(x, y + 1, cnt + 1);
            st[x][y] = false;
            st[x + 1][y] = false;
        }
    }
    else // 已经被填过了就跳过
        dfs(x, y + 1, cnt);
}
int main()
{
    n = 4;
    for (int i = 1; i <= 14; i++)
    {
        m = i;
        res = 0;
        dfs(1, 1, 0);
        cout << res << endl;
    }
}

题解代码：

// f[n] = f[n-1] + f[n-2]*5 + f[n-3] - f[n-4]
// 1   5   1   -1        f[n-1]相乘为:f[n-1]+5*f[n-2]+f[n-3]+f[n-4]=f[n]
// 1   0   0   0         f[n-2]   	 f[n-1]+0+0+0
// 0   1   0   0		 f[n-3]      0+[n-2]+0+0
// 0   0   1   0		 f[n-4]      0+0+f[n-3]+0
// ↑bas矩阵                //op矩阵: f[1]=1,f[2]=5,f[3]=11,f[4]=36;
// f[n] = qmi(bas,n-4) * op;
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define endl '\n'
const int N = 6;
const int mod = 1e9 + 7;
int n;
struct mart
{
	int t[N][N];
};
mart e;	  // 单位矩阵，做快速幂的时候用
mart bas; // 基底矩阵V(n)
void init()
{
	memset(e.t, 0, sizeof e.t);
	for (int i = 1; i <= 15; i++)
		e.t[i][i] = 1;
	memset(bas.t, 0, sizeof bas.t);
	bas.t[1][1] = 1;
	bas.t[1][2] = 5;
	bas.t[1][3] = 1;
	bas.t[1][4] = -1;
	bas.t[2][1] = 1;
	bas.t[3][2] = 1;
	bas.t[4][3] = 1;
}
mart mult(mart &a, mart &b)
{
	mart ans;
	for (int i = 1; i <= 4; i++)
	{
		for (int j = 1; j <= 4; j++)
		{
			int x = 0;
			for (int k = 1; k <= 4; k++)
			{
				x += (a.t[i][k] * b.t[k][j]);
				x %= mod;
			}
			ans.t[i][j] = x % mod;
		}
	}
	return ans;
}
mart qmi(mart a, int b, int mod)
{
	mart ans = e;
	while (b)
	{
		if (b & 1)
			ans = mult(ans, a);
		a = mult(a, a);
		b >>= 1;
	}
	return ans;
}

signed main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);

	init();
	mart op;
	memset(op.t, 0, sizeof(op.t));
	op.t[1][1] = 36;
	op.t[2][1] = 11;
	op.t[3][1] = 5;
	op.t[4][1] = 1;
	while (cin >> n)
	{
		int f = 0;
		switch (n)
		{
		case 1:
			cout << 1 << endl;
			f = 1;
			break;
		case 2:
			cout << 5 << endl;
			f = 1;
			break;
		case 3:
			cout << 11 << endl;
			f = 1;
			break;
		case 4:
			cout << 36 << endl;
			f = 1;
			break;
		}
		if (f == 1)
			continue;

		mart res = qmi(bas, n - 4, mod);
		res = mult(res, op);
		cout << (res.t[1][1] + mod) % mod << endl;
	}
}