动态规划之花园

题目描述
小 L 有一座环形花园，沿花园的顺时针方向，他把各个花圃编号为 1∼n。花园 1 和 n 是相邻的。

他的环形花园每天都会换一个新花样，但他的花园都不外乎一个规则：任意相邻 m 个花圃中都只有不超过 k 个 C 形的花圃，其余花圃均为 P 形的花圃。

例如，若 n=10 , m=5 , k=3 ，则

• CCPCPPPPCC 是一种不符合规则的花圃。
• CCPPPPCPCP 是一种符合规则的花圃。

请帮小 L 求出符合规则的花园种数对 109+7 取模的结果。

输入格式

只有一行三个整数，分别表示 n,m,k。

输出格式

输出一行一个整数表示答案。

输入输出样例

输入 #1复制

10 5 3

输出 #1复制

458

输入 #2复制

6 2 1

输出 #2复制

18

思路：

 

先考虑普通的DP，因为 m≤5，可以状压。

从第二个样例来看，m=2,k=1，有状态

00→{_00_01​01→{_10​10→{_00_01​

可以知道前状态的最右几位要和后状态相同，不过最前面的一位被挤出去了，有没有摆C花没有关系， 01 皆可，因此设前状态为 i，后状态为 j，可以得到 i,j 关系：

i={j>>1(j>>1) ∣ (1<<(m−1))​

另设 f[i][j] 为到第 i 盆花，前面 m 盆的状态为 j，可以由上面的关系得到DP方程：

f[i][j]=f[i][j]+{f[i−1][j>>1]f[i−1][(j>>1) ∣ (1<<(m−1))​

需要判一下第二个转移的前状态是否合法。

然后要处理环形的问题，可以简单的短环成链，然后对于给定初状态 f[0][s] ，统计DP后的 f[n][s] 计入答案。这是因为这样对于一个长度为 n 的环， i=0 和 i=n 是等价的，所以 j0​,jn​ 相同的时候就是一个合法的环。

依照这个思路写出40分代码:

#include 

int f[100000][1 << 5];
int n, m, K;
int t, ans;
int main() {
    n = read(); m = read(); K = read();
    t = (1 << m) - 1;
    for (int statu = 0; statu <= t; ++statu) {
        if (__builtin_popcount(statu) > K) continue;
        memset(f, 0, sizeof(f));
        f[0][statu] = 1;
        for (int i = 1; i <= n; ++i) {
            for (int j = 0; j <= t; ++j) {
                f[i][j] += f[i - 1][j >> 1];
                if (__builtin_popcount((j >> 1) | (1 << (m - 1))) <= K)
                    f[i][j] += f[i - 1][(j >> 1) | (1 << (m - 1))];
            }
        }
        ans += f[n][statu];
    }

    printf("%d\n", ans);
    return 0;
}
\\ 不知道__builtin_popcount() 的可以自行百度，这是好东西

然后想着 f[i][j] 只和 f[i−1][k] 有关，所以第一维 [i] 可以滚动优化掉，然后按照这个 n 的范围肯定是得上矩阵乘法的，试着构造转移矩阵。还是以上面的 m=2,k=1 为例，状态转移还是一样的，设 f[i] 为状态为 i 时的方案数， 由 f[i] 推出 f′[i] ，就是下一轮的 f[i]；

对于任意的 m,k，也可以通过前后 i,j 两个状态的关系，令转移矩阵中的 mat[i][j]=1，构造出转移矩阵。

另外还有一点，对于之前每一个状态做一遍DP，现在我们有了矩阵，就没有必要对于 f[0][0]=1,f[0][1]=1,…,f[0][(1<

AC代码：

#include 
typedef long long lint;

inline lint read() {
	lint x = 0, f = 0; char c = getchar();
	for (; c < '0' || c > '9'; c = getchar()) if (c == '-') f = 1;
	for (; c >= '0' && c <= '9'; c = getchar()) x = (x << 3) + (x << 1) + (c ^ 48);
	return f ? -x : x;
}

const int p = 1e9 + 7;
lint n;
int m, K;
int t, ans;

struct mat {
	int row, col;
	int a[32][32];
	mat() {
		memset(a, 0, sizeof(a));
	}
	void init() {
		*this = mat();
		row = col = t;
		for (int i = 0; i < t; ++i)
			a[i][i] = 1;
	}
	mat operator * (const mat &x) const {
		mat ans = mat(); ans.row = row; ans.col = col;
		for (int i = 0; i < row; ++i) 
			for (int j = 0; j < col; ++j)
				for (int k = 0; k < col; ++k)
					(ans.a[i][j] += (1ll * a[i][k] * x.a[k][j]) % p) %= p;
		return ans;
	}
	mat operator ^ (lint n) {
		mat ans = mat(); 
		ans.init();
		mat base = *this;
		for (; n; n >>= 1, base = base * base)
			if (n & 1) ans = ans * base;
		return ans;
	}
} ;

int main() {
	n = read(); m = read(); K = read();
	t = 1 << m;
	mat b = mat(); b.row = b.col = t;
	for (int i = 0, j; i < t; ++i) {
		if (__builtin_popcount(i) > K) continue;
		j = i >> 1;
		// j -> i
		b.a[j][i] = 1;
		j = (i >> 1) | (1 << (m - 1));
		if (__builtin_popcount(j) <= K)
			b.a[j][i] = 1;
	}

	mat c = (b ^ n);
	for (int i = 0; i < t; ++i) {
		ans = (ans + c.a[i][i]) % p;
	}
	printf("%d\n", ans);
	return 0;
}