【算法讲8：莫比乌斯函数及其反演（理论部分） | 欧拉筛】筛素数 | 筛四种积性函数

前置

• 【算法讲7：积性函数（下）】⌈ 加性函数 ⌋ 与 ⌈ 积性函数 ⌋ 与 ⌈ 狄利克雷卷积 ⌋ 详细介绍

补充

• 主要参考：
  OI Wiki 莫比乌斯反演 OI WIKI
  常见的5个数论函数线性筛求法
  线性筛的理解及其应用
  把十分重要的内容拎出来了，不是很全。要看全的可以看前置内容的算法讲。
  依旧是重要部分有证明，证明出来的话会有底数，且证明方法也同等重要。
  如有错误恳请斧正

$\lceil$莫比乌斯函数$\rfloor$

定义

• $\mu (n)=\{\begin{array}{ll}1& n=1\\ 0& n有大于1的平方因子\\ (-1{)}^{\omega (n)}& 其他\end{array}$
  其中 $\omega (n)$ 表示 $n$ 的本质不同的质因子个数，是个加性函数。

性质

• 性质一：$\mu (n)$ 是乘性函数。
• 性质二：$\sum _{d|n}\mu (d)=\epsilon (n)$，即 $\mu \ast 1=\epsilon$
  证明：性质一、二见【算法讲5：乘性函数（中）】
• 性质三：反演结论： $[\gcd (i,j)=1]=\sum _{d|\gcd (i,j)}\mu (d)$
  证明：$[\gcd (i,j)=1]=\epsilon (\gcd (i,j))=\mu \ast 1$，展开即可。

$\lceil$莫比乌斯反演$\rfloor$

• 两种反演方式：
  设 $f、g$ 为数论函数
  如果有 $f(n)=\sum _{d|n}g(d)$ 那么有 $g(n)=\sum _{d|n}\mu (d)f(\frac{n}{d})$
  如果有 $f(n)=\sum _{n|d}g(d)$ 那么有 $g(n)=\sum _{n|d}\mu (\frac{d}{n})f(d)$
  （1）用狄利克雷卷积证明第一种反演：
  已知 $f=g\ast 1$，那么 $f\ast \mu =g\ast 1\ast \mu =g\ast \epsilon =g$，即 $g=\mu \ast f$
  （2）用数论变换证明第一种反演：
  $$\begin{array}{rl}\sum _{d|n}\mu (d)f(\frac{n}{d})& =\sum _{d|n}\mu (d)\sum _{k|\frac{n}{d}}g(k)\\ & =\sum _{k|n}g(k)\sum _{d|\frac{n}{k}}\mu (d)\\ & =\sum _{k|n}g(k)\epsilon (\frac{n}{k})\\ & =g(n)\square \end{array}$$
  （3）用数论变换证明第二种反演：
  $$\begin{array}{rl}\sum _{n|d}\mu (\frac{d}{n})f(d)& =\underset{k=1}{\sum ^{+\infty }}\mu (k)f(kn)\\ & =\underset{k=1}{\sum ^{+\infty }}\mu (k)\sum _{nk|d}g(d)\\ & =\sum _{n|d}g(d)\sum _{k|\frac{d}{n}}\mu (k)\\ & =\sum _{n|d}g(d)\epsilon (\frac{d}{n})\\ & =g(n)\square \end{array}$$

$\lceil$线性筛$\rfloor$

• 对于一个积性函数，如果该函数 $f(p^k)$ 可以在 $O(logN)$ 之内算出来，那么该积性函数可以被线性筛。
  线性筛，即在 $O(N)$ 的时间复杂度下，算出每个整数点位置的 $f(i)$ 积性函数，或者用来筛出小于等于 $n$ 的所有质数
• 线性筛的水还算深，大体内容包含一下部分：
  埃筛(埃拉托色尼斯晒)
  欧拉筛
  欧拉筛可以搭配筛各种积性函数
  洲阁筛
  杜教筛
  Min_25筛
  够我学好久了。。
• 出于文章内容要求，我们这里讲的是欧拉筛质数与莫比乌斯函数等
  前置知识：埃筛（默认大家都会了）
• 为什么要讲这个嘞、、因为这些筛是做出莫比乌斯反演题目的基础

$\lceil$欧拉筛：筛素数$\rfloor$

• 例题：【模板】线性筛素数 | 洛谷 P3383
• 与埃筛相比，欧拉筛 之所以时间复杂度为 $O(N)$ ，因为它保证了所有数字只被它的最小质因子筛去
• 原理：与埃筛类似但不完全一样，我们拿出每一个数 $i$ 。
  （1）如果 $i$ 还没有被筛去，那它就是一个素数。
  （2）我们拿 $i$ 的所有目前已获得的素数倍 $i\times prime[j]$ 去筛之后的那些数字，并把他们的标记设置为 $1$。因为那些数字明显能被分解为 $i\times prime[j]$，所以他们不是素数。
  （3）其中保证了 $prime[j]$ 是 $i\times prime[j]$ 的最小质因数。怎么保证的呢？
  我们思考 $210=2\times 3\times 5\times 7$
  肯定有当 $i=3\times 5\times 7$ 的时候，取得的 $prime[1]=2$，这时 $i\times prime[1]=210$，于是 $210$就被筛掉了一次。
  如果当 $i=2\times 5\times 7$，如果当 $prime[2]=3$ 取到了的话，那么此时 $i\times prime[2]=210$，这个数字又要被筛掉一次了！
  我们想保证筛掉所有数字都被该数字的最小质因数筛掉，也就是说正向枚举 $prime[1]$到$prime[cnt]$，如果存在某一个 $prime[j]$ 是 $i$ 的因子了，那么再继续筛的话，$prime[j]$ 都不可能是 $i\times prime[j]$ 的最小质因数。

bool vis[MAX];
int prime[MAX];
int cnt;
void shai(int n){
    
    
    for(int i = 2;i <= n;++i){
    
    
        if(!vis[i])
            prime[++cnt] = i;								/// （1）
        for(int j = 1;j <= cnt && i * prime[j] <= n;++j){
    
    
            vis[i*prime[j]] = 1;							/// （2）
            if(i%prime[j]==0)break;							/// （3）
        }
    }
}

• 我们发现了什么？发现代码中的 $prime[j]$ 一定是 $i\times prime[j]$ 的最小质因数！
  这一条非常重要的性质为我们线性筛一些基本的积性函数做出了铺垫。

---

$\lceil$欧拉筛：筛莫比乌斯函数$\rfloor$

• 怎么筛呢？考虑到，莫比乌斯函数是积性函数，我们就要用积性函数的性质，即：
  若 $m,n\in {\mathbb{N}}^{+}$ 且 $m\perp n$，则有 $f(mn)=f(m)f(n)$
  当然我们还需要知道 $f(p)$ 是多少。
• 带入莫比乌斯函数，根据定义：
  $\mu (n)=\{\begin{array}{ll}1& n=1\\ 0& n有大于1的平方因子\\ (-1{)}^{\omega (n)}& 其他\end{array}$
  其中 $\omega (n)$ 表示 $n$ 的本质不同的质因子个数，是个加性函数。
• 考虑到欧拉筛只会把每个数给筛一次，且每次会给出该数字的最小质数与最大因数的乘积
  我们就要把筛法往这里靠拢：
• 设 $p$ 是 $n$ 的最小素数
  （1）$\mu (p)=-1$
  （2）$n=p\times i$ 且 $p\perp i$，那么 $\mu (p\times i)=\mu (p)\mu (i)=-\mu (i)$
  （3）$n=p\times i$ 且 $p/\perp i$，那么 $\mu (p\times i)=0$

我们轻松即可把欧拉筛素数的板子转化为欧拉筛莫比乌斯函数的板子：

bool vis[MAX];
int prime[MAX];
int mu[MAX];
int cnt;
void shai(int n){
    
    
    mu[1] = 1;
    for(int i = 2;i <= n;++i){
    
    
        if(!vis[i]){
    
    
            prime[++cnt] = i;
            mu[i] = -1;
        }
        for(int j = 1;j <= cnt && i * prime[j] <= n;++j){
    
    
            vis[i*prime[j]] = 1;
            if(i % prime[j])mu[i*prime[j]] = -mu[i];
            else {
    
    
            	mu[i*prime[j]] = 0;
                break;
            }
        }
    }
}

---

$\lceil$欧拉筛：筛欧拉函数$\rfloor$

• 欧拉函数的定义及其推导公式是啥：
  $\phi (n)=\underset{i=1}{\sum ^n}[\gcd (i,n)=1]=n\times \prod \frac{p_i-1}{p_i}$
• 欧拉函数也是积性函数
  $\forall m,n\in {\mathbb{N}}^{+}$，如果 $m\perp n$ 则有 $\phi (mn)=\phi (m)\phi (n)$
• 设 $p$ 是 $n$ 的最小素数：
  （1）$\phi (p)=p-1$
  （2）$n=p\times i$ 有 $i\perp p$，则有 $\phi (i\times p)=\phi (i)\phi (p)=\phi (i)\times (p-1)$
  （3）$n=p\times i$ 有 $i/\perp p$，则有 $\phi (i\times p)=p\times i\times \prod \frac{p_i-1}{p_i}=p\times \phi (i)$
  为啥嘞？因为此时 $i$ 包含了所有 $n$ 的素数因子。
• 感觉跟上面一样的套路，我作为小萌新，也会生推板子了呢 ???胡说你明明之前推错了

bool vis[MAX];
int prime[MAX];
int phi[MAX];
int cnt;
void shai(int n){
    
    
    phi[1] = 1;
    for(int i = 2;i <= n;++i){
    
    
        if(!vis[i]){
    
    
            prime[++cnt] = i;
            phi[i] = i - 1;
        }
        for(int j = 1;j <= cnt && i * prime[j] <= n;++j){
    
    
            vis[i*prime[j]] = 1;
            if(i % prime[j])phi[i*prime[j]] = phi[i] * (prime[j] - 1);
            else {
    
    
            	phi[i*prime[j]] = phi[i] * prime[j];
                break;
            }
        }
    }
}

$\lceil$欧拉筛：筛约数个数函数$\rfloor$

• 约数个数函数的定义及其推导是啥？
  $d(n)=\tau (n)=\sum _{d|n}1=\prod (a_i+1)$
  它也是个积性函数。继续怎么筛呢？
• 设 $p$ 是 $n$ 的最小素数：
  （1）$d(p^k)=k+1$
  （2）$n=p\times i$ 有 $i\perp p$，则有 $d(p\times i)=d(p)d(i)=2d(i)$
  （3）$n=p\times i$ 有 $i/\perp p$，即 $i$ 含有 $prime[j]$ 的因子。
  我们需要知道 $i$ 的最小素数幂次 $mp(i)$ 是多少，然后把 $i$ 中的该项的因子全拿出来即可
  即：$d(i\times p)=d(\frac{i}{p^{mp(i)}})d(p^{mp(i)+1})=\frac{d(i)}{mp(i)+1}\times (mp(i)+2)$
• 那我们还要去维护这个 $mp(i)$，怎么维护呢？
• 设 $p$ 是 $n$ 的最小素数：
  （1） $mp(p)=1$
  （2）$n=p\times i$ 有 $i\perp p$，则有 $mp(n)=1$
  （3）$n=p\times i$ 有 $i/\perp p$，则有 $mp(n)=mp(i)+1$
  因为保证了 $p$ 是 $n$ 的最小质数，即此时 $i$ 的最小质数也是 $p$ 。

bool vis[MAX];
int prime[MAX];
int mp[MAX];
int tau[MAX];
int cnt;
void shai(int n){
    
    
    tau[1] = 1;
    mp[1] = 0;
    for(int i = 2;i <= n;++i){
    
    
        if(!vis[i]){
    
    
            prime[++cnt] = i;
            tau[i] = 2;
            mp[i] = 1;
        }
        for(int j = 1;j <= cnt && i * prime[j] <= n;++j){
    
    
            vis[i*prime[j]] = 1;
            if(i % prime[j]){
    
    
            	tau[i*prime[j]] = tau[i] * 2;
                mp[i*prime[j]] = 1;
            }else {
    
    
            	tau[i*prime[j]] = tau[i] / (mp[i] + 1) * (mp[i] + 2);
                mp[i*prime[j]] = mp[i] + 1;
                break;
            }
        }
    }
}

$\lceil$欧拉筛：筛约数和函数$\rfloor$

• 约数和函数的定义及其推导是啥？
  $\sigma (n)=\sum _{d|n}d=\prod \frac{p_i^{a_i+1}-1}{p_i-1}$
  它也是个积性函数。继续怎么筛呢？已经直接是复读机了啊喂
• 设 $p$ 是 $n$ 的最小素数：
  （1）$\sigma (p^k)=\frac{p^{k+1}-1}{p-1}$
  （2）$n=p\times i$ 有 $i\perp p$，那么 $\sigma (p\times i)=\sigma (p)\sigma (i)=(p+1)\sigma (i)$
  （3）$n=p\times i$ 有 $i/\perp p$，那么我们依然要把 $i$ 的最小素数幂次 $mp(i)$ 是多少得到，拿出来后
  $\sigma (p\times i)=\sigma (\frac{i}{p^{mp(i)}})\sigma (p^{mp(i)+1})=\frac{\sigma (n)}{\sigma (p^{mp(i)})}\sigma (p^{mp(i)+1})=\sigma (n)\times \frac{p^{mp(i)+2}-1}{p^{mp(i)+1}-1}$
  啊这，如果还要用快速幂啥算的话，时间复杂度会大打折扣呀！我们稍微改一下定义好了：
  （3${}^{\star }$）$n=p\times i$ 有 $i/\perp p$，我们设 $mp(i)$ 表示 $i$ 的最小幂因数的幂次方。
  说白了就是用 $mp(i)$ 代替原来的 $p^{mp(i)}$
  $\sigma (p\times i)=\sigma (\frac{i}{mp(i)})\sigma (mp(i)+1)=\sigma (i)\times \frac{mp(i)\times p^2-1}{mp(i)\times p-1}$
• 那我们还要去维护这个新的 $mp(i)$，怎么维护呢？
• 设 $p$ 是 $n$ 的最小素数：
  （1） $mp(p)=p$
  （2）$n=p\times i$ 有 $i\perp p$，则有 $mp(n)=p$
  （3）$n=p\times i$ 有 $i/\perp p$，则有 $mp(n)=mp(i)\times p$
  很好理解！ 好理解个P你之前又推错了
  注意不要上溢了。

bool vis[MAX];
int prime[MAX];
ll mp[MAX];
ll sigma[MAX];
int cnt;
void shai(int n){
    
    
    sigma[1] = 1;
    mp[1] = 1;
    for(int i = 2;i <= n;++i){
    
    
        if(!vis[i]){
    
    
            prime[++cnt] = i;
            sigma[i] = i + 1;
            mp[i] = i;
        }
        for(int j = 1;j <= cnt && i * prime[j] <= n;++j){
    
    
            vis[i*prime[j]] = 1;
            if(i % prime[j]){
    
    
            	sigma[i*prime[j]] = sigma[i] * (prime[j] + 1);
                mp[i*prime[j]] = prime[j];
            }else {
    
    
                sigma[i*prime[j]] = sigma[i] * (mp[i] * prime[j] * prime[j] - 1) / (mp[i] * prime[j] - 1);
                mp[i*prime[j]] = mp[i] * prime[j];
                break;
            }
        }
    }
}