洛谷P4213 杜教筛模板

[模板]杜教筛：

计算
$$\begin{gathered} \sum _{i=1}^n\mu (i) \\ \sum _{i=1}^n\varphi (i) \end{gathered}$$

Solution：

杜教筛是一种能在$O(n^{\frac{2}{3}})$时间复杂度下计算积性函数的前缀和的算法，假设我们需要求积性函数$f(x)$的前$n$项和
$$S(n)=\sum _{i=1}^{n}f(i)$$
我们不妨找多一个积性函数$g(x)$，考虑他们的迪利克雷卷积的前$n$项和
$$\sum _{i=1}^n(f\ast g)(i)=\sum _{i=1}^n\sum _{d|i}f(d)g(\frac{i}{d})$$
优先枚举因子
$$\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)$$
上式两种形式等价，但右式的第二个求和部分恰好是$S(\lfloor \frac{n}{d}\rfloor )$，于是右式有
$$\sum _{i=1}^n(f\ast g)(i)=\sum _{d=1}^{n}g(d)S(\lfloor \frac{n}{d}\rfloor )$$
将右式$d=1$部分单独考虑，即
$$\sum _{i=1}^n(f\ast g)(i)=g(1)S(n)+\sum _{d=2}^{n}g(d)S(\lfloor \frac{n}{d}\rfloor )$$
可见，要求$S(n)$，即求$g(1)S(n)$，而右式的求和部分是可以递归处理的，至此只需要找出这个$g(x)$即可，有以下这些简单的数论积性函数可供选择，这些函数比较简单，并且迪利克雷卷积有显著的特性
$$\begin{gathered} ϵ(n)=[n=1] \\ I(n)=1 \\ id(n)=n \end{gathered}$$
我们对$\mu$卷积上$I$，得到
$$(\mu \ast I)(x)=\sum _{d|x}\mu (d)I(\frac{x}{d})=\sum _{d|x}\mu (d)=[x=1]$$
上式的最后一个等号是莫比乌斯反演得到的，此式即$\mu \ast I=ϵ$

对$\varphi$卷积上$I$，得到
$$(\varphi \ast I)(x)=\sum _{d|x}\varphi (d)I(\frac{x}{d})=\sum _{d|x}\varphi (d)=x$$
最后一个等号是欧拉函数的一个性质
$$n=\sum _{d|n}\varphi (d)$$

证明：

由欧拉函数的定义
$$\varphi (n)=\sum _{i=1}^n[gcd(i,n)=1]$$
莫比乌斯反演得到
$$\varphi (n)=\sum _{i=1}^n\sum _{d|gcd(i,n)}\mu (d)$$
优先枚举因子$d$
$$\varphi (n)=\sum _{d|n}\mu (d)\lfloor \frac{n}{d}\rfloor$$
设$g(x)=x$，莫比乌斯反演的变换形式有
$$\varphi (n)=\sum _{d|n}\mu (d)g(\lfloor \frac{n}{d}\rfloor )\Rightarrow g(n)=n=\sum _{d|x}\varphi (d)$$

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

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

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

$$m=\frac{n}{\sqrt{m}}\Rightarrow m=n^{\frac{2}{3}}$$

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

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

// #include<bits/stdc++.h>
#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<algorithm>
#include<vector>
#include<bitset>
#include<map>
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;
}