洛谷P4213 杜教筛模板

[模板]杜教筛:

计算
∑ i = 1 n μ ( i ) ∑ i = 1 n ϕ ( i ) \sum_{i=1}^{n}\mu(i)\\\sum_{i=1}^{n}\phi(i) i=1nμ(i)i=1nϕ(i)

Solution:

杜教筛是一种能在 O ( n 2 3 ) O(n^{\frac{2}{3}}) O(n32)时间复杂度下计算积性函数的前缀和的算法,假设我们需要求积性函数 f ( x ) f(x) f(x)的前 n n n项和
S ( n ) = ∑ i = 1 n f ( i ) S(n)=\sum_{i=1}^{n}f(i) S(n)=i=1nf(i)
我们不妨找多一个积性函数 g ( x ) g(x) g(x),考虑他们的迪利克雷卷积的前 n n n项和
∑ i = 1 n ( f ∗ g ) ( i ) = ∑ i = 1 n ∑ d ∣ i f ( d ) g ( i d ) \sum_{i=1}^{n}(f*g)(i)=\sum_{i=1}^{n}\sum_{d|i}f(d)g(\frac{i}{d}) i=1n(fg)(i)=i=1ndif(d)g(di)
优先枚举因子
∑ d = 1 n f ( d ) ∑ i = 1 ⌊ n d ⌋ g ( i ) = ∑ d = 1 n g ( d ) ∑ i = 1 ⌊ n d ⌋ f ( i ) \sum_{d=1}^{n}f(d)\sum_{i=1}^{\lfloor\frac{n}{d}\rfloor}g(i)=\sum_{d=1}^{n}g(d)\sum_{i=1}^{\lfloor\frac{n}{d}\rfloor}f(i) d=1nf(d)i=1dng(i)=d=1ng(d)i=1dnf(i)
上式两种形式等价,但右式的第二个求和部分恰好是 S ( ⌊ n d ⌋ ) S(\lfloor\frac{n}{d}\rfloor) S(⌊dn⌋),于是右式有
∑ i = 1 n ( f ∗ g ) ( i ) = ∑ d = 1 n g ( d ) S ( ⌊ n d ⌋ ) \sum_{i=1}^{n}(f*g)(i)=\sum_{d=1}^{n}g(d)S(\lfloor\frac{n}{d}\rfloor) i=1n(fg)(i)=d=1ng(d)S(⌊dn⌋)
将右式 d = 1 d=1 d=1部分单独考虑,即
∑ i = 1 n ( f ∗ g ) ( i ) = g ( 1 ) S ( n ) + ∑ d = 2 n g ( d ) S ( ⌊ n d ⌋ ) \sum_{i=1}^{n}(f*g)(i)=g(1)S(n)+\sum_{d=2}^{n}g(d)S(\lfloor\frac{n}{d}\rfloor) i=1n(fg)(i)=g(1)S(n)+d=2ng(d)S(⌊dn⌋)
可见,要求 S ( n ) S(n) S(n),即求 g ( 1 ) S ( n ) g(1)S(n) g(1)S(n),而右式的求和部分是可以递归处理的,至此只需要找出这个 g ( x ) g(x) g(x)即可,有以下这些简单的数论积性函数可供选择,这些函数比较简单,并且迪利克雷卷积有显著的特性
ϵ ( n ) = [ n = 1 ] I ( n ) = 1 i d ( n ) = n \epsilon(n)=[n=1]\\ I(n)=1\\ id(n)=n ϵ(n)=[n=1]I(n)=1id(n)=n
我们对 μ \mu μ卷积上 I I I,得到
( μ ∗ I ) ( x ) = ∑ d ∣ x μ ( d ) I ( x d ) = ∑ d ∣ x μ ( d ) = [ x = 1 ] (\mu * I)(x)=\sum_{d|x}\mu(d)I(\frac{x}{d})=\sum_{d|x}\mu(d)=[x=1] (μI)(x)=dxμ(d)I(dx)=dxμ(d)=[x=1]
上式的最后一个等号是莫比乌斯反演得到的,此式即 μ ∗ I = ϵ \mu *I=\epsilon μI=ϵ

ϕ \phi ϕ卷积上 I I I,得到
( ϕ ∗ I ) ( x ) = ∑ d ∣ x ϕ ( d ) I ( x d ) = ∑ d ∣ x ϕ ( d ) = x (\phi * I)(x)=\sum_{d|x}\phi(d)I(\frac{x}{d})=\sum_{d|x}\phi(d)=x (ϕI)(x)=dxϕ(d)I(dx)=dxϕ(d)=x
最后一个等号是欧拉函数的一个性质
n = ∑ d ∣ n ϕ ( d ) n=\sum_{d|n}\phi(d) n=dnϕ(d)

证明:

由欧拉函数的定义
ϕ ( n ) = ∑ i = 1 n [ g c d ( i , n ) = 1 ] \phi(n)=\sum_{i=1}^{n}[gcd(i,n)=1] ϕ(n)=i=1n[gcd(i,n)=1]
莫比乌斯反演得到
ϕ ( n ) = ∑ i = 1 n ∑ d ∣ g c d ( i , n ) μ ( d ) \phi(n)=\sum_{i=1}^{n}\sum_{d|gcd(i,n)}\mu(d) ϕ(n)=i=1ndgcd(i,n)μ(d)
优先枚举因子 d d d
ϕ ( n ) = ∑ d ∣ n μ ( d ) ⌊ n d ⌋ \phi(n)=\sum_{d|n}\mu(d) \lfloor \frac{n}{d} \rfloor ϕ(n)=dnμ(d)dn
g ( x ) = x g(x)=x g(x)=x,莫比乌斯反演的变换形式有
ϕ ( n ) = ∑ d ∣ n μ ( d ) g ( ⌊ n d ⌋ ) ⇒ g ( n ) = n = ∑ d ∣ x ϕ ( d ) \phi(n)=\sum_{d|n}\mu(d) g(\lfloor \frac{n}{d} \rfloor) \Rightarrow g(n)=n=\sum_{d|x}\phi(d) ϕ(n)=dnμ(d)g(⌊dn⌋)g(n)=n=dxϕ(d)

于是只要选取 g ( x ) = I ( x ) g(x)=I(x) g(x)=I(x)就可以解决原题的问题了。至此,可以在 O ( n 3 4 ) O(n^{\frac{3}{4}}) O(n43)内解决上述问题,但还可以优化

  • 对于 S ( i ) S(i) S(i),我们可以记忆化他,这样常数减小

  • 假设我们线性筛先求出 n ∈ [ 1 , m ] n\in[1,m] n[1,m]的前缀和,这样的时间复杂度是 O ( m + n m ) O(m+\frac{n}{\sqrt{m}}) O(m+m n)的,我们设 m = n k m=n^k m=nk,我们尽量让两部分的时间复杂度相等,这样总复杂度取得最小,即

m = n m ⇒ m = n 2 3 m=\frac{n}{\sqrt{m}}\Rightarrow m=n^{\frac{2}{3}} m=m nm=n32

此时总复杂度是 O ( n 2 3 ) O(n^{\frac{2}{3}}) O(n32)

(复杂度的证明我也不太会,尚且知道 O ( n 3 4 ) O(n^{\frac{3}{4}}) O(n43) O ( n m ) O(\frac{n}{\sqrt{m}}) O(m n)两个关键复杂度)

// #include
#include
#include
#include
#include
#include
#include
#include
#include
using namespace std;

using ll=long long;
const int N=1700005,inf=0x3fffffff;
const long long INF=0x3fffffffffffffff,mod=20101009;

ll n,mu[N],prime[N],phi[N],cnt;
bool nt[N];

map<ll,ll>map1,map2;

void make_prime()
{
    mu[1]=phi[1]=1;
    for(int i=2;i<N;i++)
    {
        if(!nt[i]) prime[++cnt]=i,phi[i]=i-1,mu[i]=-1;
        for(int j=1;j<=cnt&&i*prime[j]<N;j++)
        {
            nt[i*prime[j]]=true;
            if(i%prime[j]==0)
            {
                mu[i*prime[j]]=0;
                phi[i*prime[j]]=prime[j]*phi[i];
                break;
            }
            else
            {
                mu[i*prime[j]]=mu[i]*mu[prime[j]];
                phi[i*prime[j]]=phi[i]*phi[prime[j]];
            }
        }
    }
    for(int i=1;i<N;i++)
    {
        mu[i]+=mu[i-1];
        phi[i]+=phi[i-1];
    }
}

ll calcphi(ll n)
{
    if(n<N) return phi[n];
    if(map1.count(n)) return map1[n];
    ll ret=1ll*n*(n+1)/2;
    for(ll l=2,r;l<=n;l=r+1)
    {   
        r=n/(n/l);
        ret-=1ll*(r-l+1)*calcphi(n/l);
    }
    return map1[n]=ret;
}

ll calcmu(ll n)
{
    if(n<N) return mu[n];
    if(map2.count(n)) return map2[n];
    ll ret=1;
    for(ll l=2,r;l<=n;l=r+1)
    {
        r=n/(n/l);
        ret-=1ll*(r-l+1)*calcmu(n/l);
    }
    return map2[n]=ret;
}

int main()
{
    make_prime();
    int t; cin>>t;
    while(t--)
    {
        cin>>n;
        printf("%lld %lld\n",calcphi(n),calcmu(n));
    }
    return 0;
}

你可能感兴趣的:(算法)