题解：洛谷P1357 花园

Description

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

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

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

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

· CCPPPPCPCP 是一种符合规则的花圃。

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

Hints

对于$40\%$的数据，$n \leq 20$

对于$60\%$的数据，$m = 2$

对于$80\%$的数据，$n \leq 10 ^5$

对于$100\%$的数据，$2 \leq n \leq 10^{15},\ 2 \leq m \leq min(n,5),\ 1 \leq k < m$

Algorithm

单看Description可能以为这是个纯数学题，然而上手就能发现这玩意不太可做。

其实，这题其实已经把算法写在脸上了。

首先可以观察到 $m$ 的值很小，因此显然需要状态压缩。

接着容易发现 $n$ 的量级对于状态压缩来说大得离谱，因此显然是矩阵加速递推做的。

不管计数DP有没有最优子结构，姑且也算DP吧，那么这题就是个矩阵加速的计数类环形状压DP。

接下来把递推式搞出来就完了。

先给出一些约定：

我们考虑把放 C 当做 1 ，放 P 当做 0 ，将相邻 $m$ 位的摆花方法当成一个二进制数压缩。

因为转移时左移操作会带来麻烦，所以把二进数的位置与原串摆法相反。

所有位运算符号均采用 C++ 中的样式。

Step 1

先考虑普通的状压DP：

我们用 dp[i - 1][j] 表示考虑到第 $i - 1$ 个位置，后 $m$ 位顺次摆花的状态为 $j$ 时的方案数。

如果把第 $i$ 位设为 0 ，那么显然有新状态 j' = j >> 1 ，

如果把第 $i$ 位设为 1 ，那么显然有新状态 j' = (j >> 1) | (1 << (m - 1)) ，

那么 dp[i][j] 显然就是dp[i - 1][j >> 1] 与 dp[i - 1][(j >> 1) | (1 << (m - 1))]求和得到的。

注意后者不一定合法，需要 __builtin_popcount() 判断一下。 //这是个统计二进制数中 1 的个数的函数，奇快无比。

最后，其实这题环的特征其实并不明显，

对于前 $m$ 位状态为 t 的情况来说，我们只需要递推完事之后将 dp[n][t] 计入答案即可。

当然，容易注意到 dp[i][] 只与 dp[i - 1][] 有关，可以滚动优化一下：

细节的小技巧就不细说了，容易写出代码：

int ans = 0, ful = 1 << m, p = m - 1;

for(int t = 0; t != ful; ++t)

{

    if(__builtin_popcount(t) > k) continue;

    memset(dp, 0, sizeof(dp));

    dp[0][t] = 1;

    for(int i = 1; i <= n; ++i)

        for(int j = 0; j <= ful; ++j)

        {

            dp[i & 1][j] = dp[i - 1 & 1][j >> 1];

            if(__builtin_popcount((j >> 1) | (1 << p)) <= k)

                dp[i & 1][j] += dp[i - 1 & 1][(j >> 1) | (1 << p)];

        }

    ans += dp[n & 1][t];

}

复杂度显然是 $O(n\cdot 4^m)$ 的。

Step 2

接下来就需要构造递推矩阵了。

以 $m = 2, k = 1$ 为例，我们有

dp[n][00] = dp[n - 1][00] + dp[n - 1][01];

dp[n][01] = dp[n - 1][10];

dp[n][10] = dp[n - 1][00] + dp[n - 1][01];

dp[n][11] = 0;

从而有转移方程：

\[\left[
\begin{matrix}
dp_{n，00} \\
dp_{n，01} \\
dp_{n，10} \\
dp_{n，11} \\
\end{matrix}
\right]
=
\left[
\begin{matrix}
1 & 1 & 0 & 0 \\
0 & 0 & 1 & 0 \\
1 & 1 & 0 & 0 \\
0 & 0 & 0 & 0
\end{matrix}
\right]
\left[
\begin{matrix}
dp_{n - 1，00} \\
dp_{n - 1，01} \\
dp_{n - 1，10} \\
dp_{n - 1，11} \\
\end{matrix}
\right]
\]

（$\LaTeX$ 的矩阵也太难写了吧……）

类似地，对于具体的 $m,k$ ，

我们可以使用和上面的递推程序相同的方法构造出类似的矩阵。

最后同样来考虑环的问题。

根据 Step 1 中的分析，答案实际上就是$\sum dp[\ n\ ][\ j\ ]$，在我们这里又有

\[\left[
\begin{matrix}
dp_{n，00\dots0} \\
dp_{n，00\dots1} \\
\vdots \\
dp_{n，11\dots0} \\
dp_{n，11\dots1} \\
\end{matrix}
\right]
=
\begin{bmatrix}
1 & 1 & \cdots & 0 & 0 \\
0 & 0 & \cdots & 0 & 0 \\
\vdots & \vdots & \ddots & \vdots & \vdots \\
0 & 0 & \cdots\ & 0 & 0\\
0 & 0 & \cdots\ & 1 & 1 \\
\end{bmatrix}
^ n
\left[
\begin{matrix}
1\\
1\\
\vdots \\
0\\
0\\
\end{matrix}
\right]
\]

（特别应当注意，右侧列向量并非全 1 向量）

如果把右侧列向量表示出来乘上去再求和，自然能做，不过有些麻烦了。

这里实际上有个绝妙的性质：

考虑构造出来的矩阵 $A$ , $A_{i,j}$ 实际上表示了状态 $j$ 可以向状态 $i$ 转移。

而由于环首尾相连的特性，对于一个合法的状态（也就是右侧列向量中对应值为 1 的状态），

在 $n$ 次转移后，该状态一定可以转移回原状态，也即是说 $A_{i,i}$ 一定非零。

而在矩阵做了 $n$ 次幂乘之后， $A_{i,i}$ 也就是起始状态为 $i$ 的方案数。

因此答案实际上即为 $\sum A_{i,i}$。

$\sum A_{i,i} = \sum dp[\ n\ ][\ j\ ]$ 的代数证明留给读者。（这能证吗？不管了，我们读者肯定会）

最后写写代码：

#include<bits/stdc++.h>

using namespace std;

#define cnt __builtin_popcount

#define rep(i, n) for(int i = 0; i != n; ++i)

typedef long long ll;

const int P = 1e9 + 7;

ll n, m, k;

class Matrix {

private:

	vector<vector<int> > num;

public:

	Matrix() {}

	Matrix(int n) {

		num.resize(n);

		rep(i, n) num[i].resize(n, 0);

	}

	int &operator () (int i, int j) {

		return num[i][j];

	}

	inline void print()

	{

		int len = num.size();

		for(int i = 0; i != len; ++i)

		{

			printf("%d", num[i][0]);

			for(int j = 1; j != len; ++j)

				printf(" %d", num[i][j]);

			puts("");

		}

	}

	inline int solve()

	{

		int ans = 0, len = num.size();

		for(int i = 0; i != len; ++i)

			(ans += num[i][i]) %= P;

		return ans;

	}

	friend Matrix operator * (Matrix a, Matrix b)

	{

		int len = a.num.size();

		Matrix ret(len);

		rep(k, len) rep(i, len) rep(j, len) {

			(ret(i, j) += (1LL * a(i, k) * b(k, j)) % P) %= P;

		}

		return ret;

	}

	friend Matrix operator ^ (Matrix a, ll n)

	{

		int len = a.num.size();

		Matrix ret(len);

		rep(i, len) ret(i, i) = 1;

		while(n)

		{

			if(n & 1)	ret = ret * a;

			a = a * a, n >>= 1;

		}

		return ret;

	}

};

int main()

{

	cin >> n >> m >> k;

	int ful = 1 << m, p = m - 1;

	Matrix cal(ful);

	for(int t = 0; t != ful; ++t)

	{

		if(cnt(t) > k)	continue;

		cal(t >> 1, t) = 1;

		int sta = (t >> 1) | (1 << p);

		if(cnt(sta) <= k)	cal(sta, t) = 1;

	}

	cout << (cal ^ n).solve() << endl;

	return 0;

}

这个代码非常之丑。最开始设计模板类翻车了，没有重构而是左改右改的……

总之不是好代码，不过反正是这个意思。

复杂度 $O(log n \cdot 8 ^ m)$ 很容易过。