[bzoj4635]数论小测验解题报告

最新推荐文章于 2019-01-19 17:04:00 发布

原创最新推荐文章于 2019-01-19 17:04:00 发布 · 1k 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#数论 #dp #容斥

DP 同时被 3 个专栏收录

43 篇文章

订阅专栏

数论

35 篇文章

订阅专栏

容斥原理

4 篇文章

订阅专栏

本文探讨了在算法设计中如何通过优化技巧提高效率，包括利用反演思想简化计算过程，使用容斥原理解决复杂问题，以及通过预处理降低时间复杂度等方法。

感觉自己好蠢只会反演。。跑了整整10s。。

a n s = \sum k = l r \sum i = 1 ⌊ m k ⌋ μ (i) ⌊ ⌊ m k ⌋ i ⌋ n

$ans=\sum_{k=l}^r\sum_{i=1}^{\lfloor {m \over k} \rfloor }\mu (i) \lfloor {\lfloor {m\over k}\rfloor \over i}\rfloor^n$
这样时间复杂度就是

O(∑m√i=1i√+∑m√i=1mi−−√)=O(m34). $O(\sum_{i=1}^{\sqrt m}\sqrt i+\sum_{i=1}^{\sqrt m}\sqrt {m\over i})=O(m^{3\over 4}).$ 我还化来化去化了半天式子。。结果a了之后才发现原始的式子直接做就可以了。。
这样其实应该是

O(m34logn) $O(m^{3\over 4}\log n)$ 的，所以我们还需要预处理一下后面的幂，就可以做到

O(T(m34+m−−√logn)) $O(T(m^{3\over 4}+\sqrt m \log n))$ 了。

设f(k,x)表示[1,m]中与k的gcd是x的数的个数，则

a n s = \sum k = l r (m n - \sum d | k f (k, d) μ (k d) [d \neq k])

$ans=\sum_{k=l}^r(m^n-\sum_{d|k}f(k,d)\mu({k\over d})[d\not=k])$
按m从小到大离线处理询问，这样就可以处理f，花费

O(m2logm) $O(m^2\log m)$ ，每次询问是

O(mlogm) $O(m\log m)$ ，所以总时间复杂度是

O(m2logm+TlogT+Tmlogm) $O(m^2\log m+T\log T+Tm\log m)$

然后看了claris老司机的题解，感觉好神啊。。原来第一问可以直接考虑反面dp来搞，第二问可以先取反再容斥。

代码：

#include<cstdio>
#include<iostream>
using namespace std;
#include<cstring>
#include<cmath>
#include<algorithm>
const int T=500+5,N=1e7+5;
const int Mod=1e9+7;
int t;

typedef long long LL;
LL power(LL prod,int x){
    LL ans=1;
    for(;x;x>>=1){
        if(x&1)ans=ans*prod%Mod;
        prod=prod*prod%Mod;
    }
    return ans;
}

namespace N1{
    const int M=1e7;
    bool p[M+5];
    int prime[M];
    int mu[M+5];
    int smu[M+5];

    const int R=5000+5;
    LL pwr1[R],pwr2[R];
    void work(){
        mu[1]=1;
        for(int i=2;i<=M;++i){
            if(!p[i]){
                prime[++prime[0]]=i;
                mu[i]=-1;
            }
            for(int j=1;j<=prime[0]&&i*prime[j]<=M;++j){
                p[i*prime[j]]=1;
                if(i%prime[j])mu[i*prime[j]]=-mu[i];
                else break;
            }
        }
        for(int i=1;i<=M;++i)smu[i]=smu[i-1]+mu[i];

        while(t--){
            int n,m,l,r;
            scanf("%d%d%d%d",&n,&m,&l,&r);

            int root=sqrt(m);
            for(int i=root;i;--i){
                pwr1[i]=power(i,n);
                pwr2[i]=power(m/i,n);
            }

            LL ans=0;
            for(int i=1,j,tmp=m/i;i<=m&&tmp>=l;i=j+1,tmp=m/i){
                j=m/tmp;

                //printf("---[%d,%d]---\n",i,j);

                LL s=0;
                for(int k=l,o;k<=min(tmp,r);k=o+1){
                    o=min(tmp/(tmp/k),r);
                    if(tmp/k<=root)s=(s+(o-k+1)*pwr1[tmp/k])%Mod;
                    else s=(s+(o-k+1)*pwr2[i*k])%Mod;

                    //printf("[%d,%d]=%I64d\n",k,o,(o-k+1)*power(tmp/k,n)%Mod);
                }
                ans=(ans+s*(smu[j]-smu[i-1]))%Mod;
            }
            printf("%lld\n",(ans+Mod)%Mod);
        }
    }
}
#include<vector>
namespace N2{
    const int M=1000;
    int cnt[M+5][M+5];

    bool p[M+5];
    int prime[M];
    int mu[M+5];

    int gcd[M+5][M+5];

    struct QS{
        int n,m,l,r,i;
        bool operator < (const QS & o)const{
            return m<o.m;
        }
    }que[T];
    LL ans[T];
    void work(){
        mu[1]=1;
        for(int i=2;i<=M;++i){
            if(!p[i]){
                prime[++prime[0]]=i;
                mu[i]=-1;
            }
            for(int j=1;j<=prime[0]&&i*prime[j]<=M;++j){
                p[i*prime[j]]=1;
                if(i%prime[j])mu[i*prime[j]]=-mu[i];
                else break;
            }
        }

        for(int i=M;i;--i)gcd[i][0]=gcd[0][i]=i;
        for(int i=1;i<=M;++i)
            for(int j=1;j<=i;++j)
                gcd[i][j]=gcd[j][i]=gcd[j][i%j];

        for(int i=1;i<=t;++i){
            scanf("%d%d%d%d",&que[i].n,&que[i].m,&que[i].l,&que[i].r);
            que[i].i=i;
        }
        sort(que+1,que+t+1);
        for(int i=1,j=0;i<=t;++i){
            for(;j<=que[i].m;++j)
                for(int o=M>>1;o;--o)
                    for(int k=o<<1;k<=M;k+=o)
                        if(mu[k/o]&&o%gcd[k][j]==0)
                            ++cnt[k][o];

            ans[que[i].i]=(que[i].r-que[i].l+1)*power(que[i].m,que[i].n)%Mod;
            for(int o=1;o<=que[i].r>>1;++o)
                for(int k=o<<1;k<=que[i].r;k+=o)
                    if(k>=que[i].l&&mu[k/o])
                        ans[que[i].i]=(ans[que[i].i]+mu[k/o]*power(cnt[k][o],que[i].n))%Mod;
        }
        for(int i=1;i<=t;++i)printf("%lld\n",(ans[i]+Mod)%Mod);
    }
}
int main(){
    freopen("bzoj_4635.in","r",stdin);
    //freopen("bzoj_4635.out","w",stdout);
    int type;
    scanf("%d%d",&t,&type);
    if(type==1)N1::work();
    else N2::work();
}

总结：
①两个根号枚举套一起是 $O(n^{3\over 4})$ 的！
②直接dp确定值考虑反面是很方便的。如果把这种dp展开会发现是个容斥，但是如果直接从容斥的角度考虑就会变得非常麻烦了（因为会有什么至少、至多这种奇怪的东西）。
③虽然反演是一种容斥，但是有的时候不一定需要它，强行上反演反而会变得麻烦的。考虑一下应该具体怎么容斥。