杜教筛学习笔记

杜教筛学习笔记

设有四个数论函数\(\bf h,f,g,s\)满足\(\mathbf h=\mathbf f*\mathbf g\)，\(\mathbf s(n)=\sum\limits_{i=1}^n \mathbf f(i)\)

\[\sum\limits_{i=1}^n \mathbf h(i)=\sum\limits_{i=1}^n\sum\limits_{d|i}\mathbf g(d)\mathbf f (\frac{i}{d}) \]

\[=\sum_{i=1}^n\mathbf g(i)\sum_{j=1}^{\lfloor \frac{n}{i}\rfloor }\mathbf f(i) \]

\[=\sum_{i=1}^n\mathbf g(i)\mathbf s(\lfloor\frac{n}{i}\rfloor) \]

\[=\mathbf g(1)\mathbf s(n)+\sum_{i=2}^n \mathbf g(i) \mathbf s(\lfloor\frac{n}{i}\rfloor) \]

于是有

\[\mathbf g(1)\mathbf s(n)=\sum_{i=1}^n \mathbf h(i) -\sum_{i=2}^n \mathbf g(i) \mathbf s(\lfloor\frac{n}{i}\rfloor ) \]

我们就利用这个式子进行求和，构造一个好求的\(\mathbf h\)和\(\mathbf g\)

比如\(\epsilon=\mu*\mathbf1\)，则\(\mathbf s(n)=1-\sum\limits_{i=2}^n\mathbf s(\lfloor\frac{n}{i}\rfloor )\)

这里的复杂度我没仔细研究，放结论了。

直接进去递归进行求解的复杂度是\(O(n^{\frac{3}{4}})\)的，预处理筛出的前\(O(n^{\frac{2}{3}})\)的所求函数的前缀和可以达到平衡，复杂度\(O(n^{\frac{2}{3}})\)

事实上预处理稍微大于\(n^{\frac{2}{3}}\)的话效率会更快。

存东西最好手写\(\tt{Hash}\)或者用\(\tt{unordered\_map}\)，别用\(\tt{map}\)

Code:

#include <cstdio>
#include <unordered_map>
#define ll long long
std::unordered_map <int,ll> phi,mu;
const int N=3e6;
int pri[N+10],ispri[N+10],cnt;
ll fphi[N+10],fmu[N+10];
void init()
{
    fphi[1]=fmu[1]=1;
    for(int i=2;i<=N;i++)
    {
        if(!ispri[i])
        {
            pri[++cnt]=i;
            fphi[i]=i-1;
            fmu[i]=-1;
        }
        for(int j=1;j<=cnt&&i*pri[j]<=N;j++)
        {
            ispri[i*pri[j]]=1;
            if(i%pri[j]==0)
            {
                fphi[i*pri[j]]=fphi[i]*pri[j];
                break;
            }
            else
            {
                fphi[i*pri[j]]=fphi[i]*(pri[j]-1);
                fmu[i*pri[j]]=-fmu[i];
            }
        }
    }
    for(int i=2;i<=N;i++)
        fmu[i]+=fmu[i-1],fphi[i]+=fphi[i-1];
}
ll calphi(int n)
{
    if(n<=N) return fphi[n];
    if(phi.find(n)!=phi.end()) return phi[n];
    ll ret=1ll*n*(n+1)/2;
    for(int l=2,r;l<=n;l=r+1)
    {
        r=n/(n/l);
        ret-=1ll*(r+1-l)*calphi(n/l);
    }
    return phi[n]=ret;
}
ll calmu(int n)
{
    if(n<=N) return fmu[n];
    if(mu.find(n)!=mu.end()) return mu[n];
    ll ret=1;
    for(int l=2,r;l<=n;l=r+1)
    {
        r=n/(n/l);
        ret-=1ll*(r+1-l)*calmu(n/l);
    }
    return mu[n]=ret;
}
int main()
{
    init();
    int T,n;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d",&n);
        printf("%lld %lld\n",calphi(n),calmu(n));
    }
    return 0;
}