线性筛各类（筛每个数i的约数个数），杜教筛莫比乌斯前n项和以及欧拉函数前n项和 模板

参考博客：https://www.cnblogs.com/peng-ym/p/9446555.html
https://blog.csdn.net/skywalkert/article/details/50500009

1，线性筛素数，欧拉函数，莫比乌斯函数，筛每个数 i 的约数个数

参考博客：https://blog.csdn.net/tc_to_top/article/details/48025849

#include<bits/stdc++.h>

using namespace std;

const int maxn=1000005;
int prime[maxn],tot;/// 筛素数 ，从0下标开始存储

int mu[maxn];///莫比乌斯函数

int phi[maxn]; ///欧拉函数

///facnum[i]表示i的约数个数,mi[i]，表示i的最小质因子的次幂
int facnum[maxn],d[maxn];

bool vis[maxn];

void init()
{
    tot = 0;
    phi[1] = 1;
    mu[1] = 1;
    facnum[1] = 1;
    int n=1000010;
    for(int i = 2; i < n; i++)
    {
        if(!vis[i])
        {
            phi[i] = i - 1;
            mu[i] = -1;
            prime[tot++] = i;
            facnum[i] = 2;
            d[i] = 1;
        }
        for(int j = 0; j < tot && i * prime[j] < n; j++)
        {
            vis[i * prime[j]] = true;
            if(i % prime[j] == 0)
            {
                phi[i * prime[j]] = phi[i] * prime[j];
                mu[i * prime[j]] = 0;
                facnum[i * prime[j]] = facnum[i] / (d[i] + 1) * (d[i] + 2);
                d[i * prime[j]] = d[i] + 1;
                break;
            }
            phi[i * prime[j]] = phi[i] * (prime[j] - 1);
            mu[i * prime[j]] = -mu[i];
            facnum[i * prime[j]] = facnum[i] * 2;
            d[i * prime[j]] = 1;
        }
    }
}

int main()
{
    init();
    return 0;
}

2，杜教筛莫比乌斯前n项和以及前n项欧拉函数和。

莫比乌斯前n项和：
我们设：
$$F(n)=\sum _{i=1}\mu (i)$$
我们知道有莫比乌斯函数这样一个性质：
$$\sum _{d|n}\mu (d)=[n=1]$$

$$1=\sum _{i=1}^n\sum _{d|i}\mu (d)=[n=1]$$
$$1=\sum _{i=1}^n\sum _{d=1}^{\lfloor \frac{n}{i}\rfloor }\mu (d)=[n=1]$$
$$1=\sum _{i=1}^{n}F(\lfloor \frac{n}{i}\rfloor )$$
$$1=F(n)+\sum _{i=2}^{n}F(\lfloor \frac{n}{i}\rfloor )$$
$$F(n)=1-\sum _{i=2}^{n}F(\lfloor \frac{n}{i}\rfloor )$$

欧拉函数前n项和：
首先我们知道有这个公式 $$\sum _{d|n}\phi (d)=n$$
设 $\varphi (n)={\sum }_{i=1}^n\phi (i)$，
接着就是一波推导，最后会化成这样

$$\varphi (n)=\frac{n\ast (n+1)}{2}-\sum _{i=2}^n\varphi (\lfloor \frac{n}{i}\rfloor )$$

推导过程见：神犇
公式出来了，那么我们就可以用分块的思想去求解，这里参考杜教神犇的模板。

通过这两个公式，我们可以发现，每次我们设一个我们要的函数，然后想办法把式子化成只有这个函数的表达式。

#include<bits/stdc++.h>
#include<tr1/unordered_map>
#define N 6000010
using namespace std;

typedef long long LL;

bool vis[N];
int mu[N],sum1[N],phi[N];
LL sum2[N];
int tot,prime[N];
tr1::unordered_map<LL,LL>w1;
tr1::unordered_map<int,int>w;
void get(int maxn)
{
    tot=0;
    phi[1]=mu[1]=1;
    for(int i=2;i<=maxn;i++)
    {
        if(!vis[i])
        {
            prime[++tot]=i;///素数
            mu[i]=-1;phi[i]=i-1; ///莫比乌斯函数，欧拉函数
        }
        for(int j=1;j<=tot&&prime[j]*i<=maxn;j++)
        {
            vis[i*prime[j]]=1;
            if(i%prime[j]==0)
            {
                phi[i*prime[j]]=phi[i]*prime[j];
                break;
            }
            else mu[i*prime[j]]=-mu[i],phi[i*prime[j]]=phi[i]*(prime[j]-1);
        }
    }
    
    ///预处理前maxn项的前n项和
    for(int i=1;i<=maxn;i++)sum1[i]=sum1[i-1]+mu[i],sum2[i]=sum2[i-1]+phi[i];
}
int djsmu(int x) ///杜教筛 前x项莫比乌斯函数和
{
    if(x<=6000000)return sum1[x];
    if(w[x])return w[x];
    int ans=1;
    ///整数分块
    for(int l=2,r;l>=0&&l<=x;l=r+1)
    {
        r=x/(x/l);
        ans-=(r-l+1)*djsmu(x/l);
    }
    return w[x]=ans;
}
LL djsphi(LL x) ///杜教筛 前x项欧拉函数和
{
    if(x<=6000000)return sum2[x];
    if(w1[x])return w1[x];
    LL ans=x*(x+1)/2;
    for(LL l=2,r;l<=x;l=r+1)
    {
        r=x/(x/l);
        ans-=(r-l+1)*djsphi(x/l);
    }
    return w1[x]=ans;
}
int main()
{
    int t,n;
    scanf("%d",&t);
    get(6000000);
    while(t--)
    {
        scanf("%d",&n);
        printf("%lld %d\n",djsphi(n),djsmu(n));
    }
    return 0;
}

.

.

我的标签：做个有情怀的程序员！