【[SDOI2017]序列计数】

感觉自己的复杂度感人

大概是\(O(p*\pi(m)+p^3logn)\)

还是能过去的

我们看到这么大的数据范围还是应该先想一想暴力怎么写

显然我们可以直接暴力\(dp\)

设\(dp[i][j]\)表示已经选择了\(i\)数，其中所有数的和\(mod\ p\)为\(j\)的方案数

显然方程是

\[f[i][j]=\sum_{k=1}^mdp[i-1][((j-k)\%p+p)\%p]\]

初始的状态是\(dp[0][0]=1\)，最终的答案是\(dp[n][0]\)

至于还有一个至少有一个素数的限制条件，我们可以先不管这个条件直接算一遍，之后再保证\(k\)不为素数再算一遍，两个一减就是答案了

这样暴力转移的复杂度是\(O(nmp)\)的，于是我们要考虑优化

这个转移相当的固定，于是可以矩乘优化

我们发现因为\(p\)非常的小，于是那个膜\(p\)意义下的转移会有很多重复的位置被转移过去，于是我们如果可以预处理出这样一个数组\(tot[j][k]\)

表示\(dp[i-1][k]\)会向\(dp[i][k]\)专一多少次，也就是\(dp[i][k]+=dp[i-1][j]*tot[j][k]\)

于是就有这样一个矩阵会被构造出来

(\(p=3\)的情况)

于是就可以转移了，至于\(tot[j][k]\)怎么求，这个就是很简单了

在没有素数的情况下把所有素数对应的转移减一遍就好了

代码

#include<iostream>
#include<cstring>
#include<bitset>
#include<cstdio>
#define re register
#define maxn 20000005
#define LL long long
const LL mod=20170408;
std::bitset<maxn> f;
int prime[1500000];
LL ans[101][101],a[101][101];
int m,p;
LL n;
inline void did_a()
{
    LL mid[101][101];
    for(re int i=1;i<=p;i++)
        for(re int j=1;j<=p;j++)
            mid[i][j]=a[i][j],a[i][j]=0;
    for(re int i=1;i<=p;i++)
        for(re int j=1;j<=p;j++)
            for(re int k=1;k<=p;k++)
                a[i][j]=(a[i][j]+(mid[i][k]*mid[k][j])%mod)%mod;
}
inline void did_ans()
{
    LL mid[101][101];
    for(re int i=1;i<=p;i++)
        for(re int j=1;j<=p;j++)
            mid[i][j]=ans[i][j],ans[i][j]=0;
    for(re int i=1;i<=p;i++)
        for(re int j=1;j<=p;j++)    
            for(re int k=1;k<=p;k++)
                ans[i][j]=(ans[i][j]+(mid[i][k]*a[k][j])%mod)%mod;
}
inline void Rebuild()
{
    memset(ans,0,sizeof(ans));
    memset(a,0,sizeof(a));
    for(re int i=1;i<=p;i++)
        ans[i][i]=1;
    int t=m/p;
    for(re int i=1;i<=p;i++)
        for(re int j=1;j<=p;j++)
            a[i][j]=t;
    int tot=m%p;
    for(re int i=1;i<=p;i++)
    {
        int cnt=tot,x=i-1;
        if(!x) x=p;
        while(cnt)
        {
            a[i][x]++,cnt--;
            x--;
            if(!x) x=p;
        }
    }
}
inline void out()
{
    for(re int i=1;i<=p;i++)
        {
            for(re int j=1;j<=p;j++)
            printf("%d ",a[i][j]);
            putchar(10);
        }
}
inline void quick(LL b)
{
    while(b)
    {
        if(b&1ll) did_ans();
        b>>=1ll;
        did_a();
    }
}
int main()
{
    scanf("%lld%d%d",&n,&m,&p);
    f[1]=1;
    for(re int i=2;i<=m;i++)
    {
        if(!f[i]) prime[++prime[0]]=i;
        for(re int j=1;j<=prime[0]&&prime[j]*i<=m;j++)
        {
            f[prime[j]*i]=i;
            if(i%prime[j]==0) break;
        }
    }
    Rebuild();
    quick(n);
    LL num=ans[1][1];
    Rebuild();
    for(re int i=1;i<=p;i++)
    {
        for(re int j=1;j<=prime[0];j++)
        {
            a[i][((i-1-prime[j])%p+p)%p+1]--;
            if(a[i][(i-prime[j]+p)%p+1]<0) a[i][(i-prime[j]+p)%p+1]=mod-1;
        }
    }
    quick(n);
    std::cout<<(num-ans[1][1]+mod)%mod;
    return 0;
}