洛谷P1357 花园（状态压缩 + 矩阵快速幂加速递推）

题目链接：传送门

题目：

题目描述

小L有一座环形花园，沿花园的顺时针方向，他把各个花圃编号为1~N(<=N<=^)。他的环形花园每天都会换一个新花样，但他的花园都不外乎一个规则，任意相邻M(<=M<=,M<=N)个花圃中有不超过K(<=K<M)个C形的花圃，其余花圃均为P形的花圃。

例如，N=,M=,K=。则

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

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

请帮小L求出符合规则的花园种数Mod 

由于请您编写一个程序解决此题。
输入输出格式
输入格式：

一行，三个数N,M,K。

输出格式：

花园种数Mod 

输入输出样例
输入样例#：

输出样例#：

输入样例#：

输出样例#：

说明

【数据规模】

%的数据中，N<=；

%的数据中，M=；

%的数据中，N<=^。

%的数据中，N<=^。

思路：

　　乍一看是一个环形dp：

　　对于给定的长度为M的状态，其后面长度为M-1的部分会影响下一个状态，记一个cnt1表示已经放了C型花圃的数量，那么根据当前的cnt1是否小于K，可以决定下个状态的转移。

状态：

　　f[i][j]：以第i个位置为终点的长度为M的部分，状态为j的方案数。（j是用2进制状压的一个长度为M的状态）

状态转移方程：

　　f[i][j] += f[i-1][j>>1];

　　if (count1(j) == K && !(j&1))

　　　　f[i][j] += f[i-1][(j>>1)|(1<<M)];

。。。。。。

但是N的上限高达1e15，所以常规的方法没发跑，考虑用矩阵加速。

　　那就要找状态矩阵和转移矩阵了。

状态矩阵：

　　Fn = [f[n][0], f[n][1], ... , f[n][(1<<m)-1];

转移矩阵可以通过上面的状态转移方程，用dfs预处理出来，接下来就可以用快速幂加速了。

　　因为跑N次之后和不跑的时候状态相同（环形），所以直接求转移矩阵A的N次A^N的对角线上的和即可。

代码：

#include <bits/stdc++.h>

using namespace std;
typedef long long ll;
const int MOD = 1e9 + ;

ll N, M, K;
int bin[];
ll F[][], A[][];

void addTran(int sta, int cnt1)
{
    int pre = sta >> ;
    A[pre][sta] = ;
    if (cnt1 == K && !(sta&))
        return;
    A[pre|bin[M-]][sta] = ;
}

void dfs(int dep, int sta, int cnt1)
{
    if (dep == M) {
        addTran(sta, cnt1);
        return;
    }
    dfs(dep+, sta, cnt1);//dep+1位为0
    if (cnt1 < K && dep+ < M)
        dfs(dep+, sta|bin[dep+], cnt1+);//dep+1位为1
}

void mul(ll f[][], ll a[][])
{
    ll c[][];
    memset(c, , sizeof c);
    for (int i = ; i < ; i++)
        for (int j = ; j < ; j++)
            for (int k = ; k < ; k++)
                c[i][j] = (c[i][j] + f[i][k] * a[k][j]) % MOD;
    memcpy(f, c, sizeof c);
}

int main()
{
    bin[] = ;
    for (int i = ; i <= ; i++)
        bin[i] = bin[i-] << ;
    cin >> N >> M >> K;
    memset(A, , sizeof A);
    memset(F, , sizeof F);//所有长度为M的状态
    for (int i = ; i < bin[M]; i++)
        F[i][i] = ;
    dfs(, , );//初始化转移矩阵
    dfs(, , );
    for (; N; N >>= ) {
        if (N&)
            mul(F, A);
        mul(A, A);
    }
    ll ans = ;
    for (int i = ; i < bin[M]; i++)
        ans = (ans + F[i][i]) % MOD;
    cout << ans << endl;
    return ;
}
/*
6 2 1
*/