数论与数论函数

数论与数论函数

全文参考oi-wiki.org

基础知识

快速幂

ll qpow(ll a,ll b,ll mod){
	ll res=1;
	a=a%mod;
	while(b){
		if(b&1)res=res*a%mod;
		a=a*a%mod;
		b>>=1;
	}
	return res;
}

可以分块预处理任意进制的快速幂，或者“光速幂”。

快速乘法

用于$a\ast b$爆$longlong$的情况

ll qmul(ll a,ll b,ll mod){
	ll res=0;
	while(b){
		if(b&1)res=(res+a)%mod;
		a=(a+a)%mod;
		b>>=1;
	}
	return res;
}

还有更快的方法，传说中的$O(1)$快速乘：

ll qmul(ll x,ll y,ll mod){
    return (x*y-(ll)((long double)x/mod*y)*mod+mod)%mod;     
}

整除及其性质

素数

1、素数的个数：
素数计数函数：小于等于$x$的素数的个数，用$\pi (x)$表示，随着$x$的增大，有近似结论：$\pi (x)\sim \frac{x}{\ln (x)}$
2、素数判定：
暴力判定：$O(\sqrt{n})$
素性测试：$O(k{\log }^{3}n)$（详见匡斌模板）

最大公约数

欧几里得算法

ll gcd(ll a,ll b){
	return b==0?a:gcd(b,a%b);
}

多个数的最大公约数

$gcd(a,b,c)=gcd(gcd(a,b),c)$

最小公倍数

$lcm(a,b)=a\ast b/gcd(a,b)$

多个数的最小公倍数

$lcm(a,b,c)=lcm(lcm(a,b),c)$
谨记$lcm(a,b,c)\ne a\ast b\ast c/gcd(a,b,c)$

扩展欧几里得定理

常用于求解$ax+by=gcd(a,b)$

int Exgcd(int a, int b, int &x, int &y) {
  if (!b) {
    x = 1;
    y = 0;
    return a;
  }
  int d = Exgcd(b, a % b, x, y);
  int t = x;
  x = y;
  y = t - (a / b) * y;
  return d;
}

函数返回值为$gcd(a,b)$,如果$ax+by=c$中$c$不是$gcd(a,b)$的倍数，则方程无解。

欧拉函数

$\phi (n)$表示小于等于$n$和$n$互质的数的个数。
特别地，令$\phi (1)=1$
设$n=p_1^{k_1}{p}_2^{k_2}\dots p_s^{k_s}$，那么$\phi (n)=n\ast {\prod }_{i=1}^s\frac{p_i-1}{p_i}$
若$n=p^k$,$p$是质数，那么$\phi (n)=p^{k-1}\ast (p-1)$

欧拉定理

若$gcd(a,m)=1$，则$a^{\phi (m)}\equiv 1(\mathrm{m}\mathrm{o}\mathrm{d}m)$
当m为素数时即为费马小定理。

扩展欧拉定理

$a^b\equiv \{\begin{array}{ll}{a}^{b\mathrm{m}\mathrm{o}\mathrm{d}\phi (p)},& \gcd (a,p)=1\\ a^b,& \gcd (a,p)\ne 1,b<\phi (p)\\ a^{b\mathrm{m}\mathrm{o}\mathrm{d}\phi (p)+\phi (p)},& \gcd (a,p)\ne 1,b\ge \phi (p)\end{array}(\mathrm{m}\mathrm{o}\mathrm{d}p)$
这个定理常用来欧拉降幂

同余与同余方程

剩余系

完全剩余系：对于$n$，就是集合 { 0 , 1 , … , n − 1 } \{0,1,…,n-1\} {0,1,…,n−1}。
简化剩余系：又叫既约剩余系，对于$n$，是完全剩余系中与$n$互质的元素构成的子集。

裴蜀定理

设$a,b$是不全为零的整数，则存在整数$x,y$，使得$ax+by=\gcd (a,b)$
这个定理可以扩展到$n$个数的情况

乘法逆元

如果一个线性同余方程$ax\equiv 1(\mathrm{m}\mathrm{o}\mathrm{d}b)$,则$x$称为$a\mathrm{m}\mathrm{o}\mathrm{d}b$ 的逆元，记作$a^{-1}$.

扩展欧几里得法

void exgcd(int a, int b, int& x, int& y) {
  if (b == 0) {
    x = 1, y = 0;
    return;
  }
  exgcd(b, a % b, y, x);
  y -= a / b * x;
}

费马小定理

$a^{-1}=a^{p-2}\mathrm{m}\mathrm{o}\mathrm{d}p$,可以用快速幂求$a^{p-2}$

线性求逆元

求$1,2,\dots ,n$中每个数关于$p$的逆元
首先，有$1^{-1}\equiv 1(\mathrm{m}\mathrm{o}\mathrm{d}p)$
设$p=ki+j,j<i,1<i<p$
有$ki+j\equiv 0(\mathrm{m}\mathrm{o}\mathrm{d}p)$
两边同时乘$i^{-1},j^{-1}$:
$k{j}^{-1}+i^{-1}\equiv 0(\mathrm{m}\mathrm{o}\mathrm{d}p)$
$i^{-1}\equiv -k{j}^{-1}(\mathrm{m}\mathrm{o}\mathrm{d}p)$
$i^{-1}\equiv -(\frac{p}{i})(p\mathrm{m}\mathrm{o}\mathrm{d}i{)}^{-1}(\mathrm{m}\mathrm{o}\mathrm{d}p)$

inv[1] = 1;
for (int i = 2; i <= n; ++i) 
	inv[i] = (long long)(p - p / i) * inv[p % i] % p;

线性求任意$n$个数的逆元

如果要求任意给定$n$个数的逆元（$1\le a_i<p$）。
首先计算$n$个数的前缀积，记为$s_n$,求得其逆元，记为$s{v}_n$，当把它乘上$a_n$时，就会得到$a_1$到$a_{n-1}$的积的逆元，记为$s{v}_{n-1}$，同理可得所有的$s{v}_i$，于是$a_i^{-1}$就可以用$s_{i-1}\ast s{v}_i$得到。

线性同余方程

形如$ax\equiv b(\mathrm{m}\mathrm{o}\mathrm{d}c)$的方程被称为线性同余方程，
其解和$ax+cy=b$是等价的
我们可以先解出$ax+by=\gcd (a,b)$的一组$x_0,y_0$,然后两边同时除以$\gcd (a,b)$,在乘$c$。就找到了方程的一个解。
若$\gcd (a,b)=1$，且$x_0,y_0$为方程$ax+by=c$的一组解，则该方程的任意解可表示为：$x=x_0+bt,y=y_0-at$,对任意整数t都成立。

int ex_gcd(int a, int b, int& x, int& y) {
  if (b == 0) {
    x = 1;
    y = 0;
    return a;
  }
  int d = ex_gcd(b, a % b, x, y);
  int temp = x;
  x = y;
  y = temp - a / b * y;
  return d;
}
bool liEu(int a, int b, int c, int& x, int& y) {
  int d = ex_gcd(a, b, x, y);
  if (c % d != 0) return 0;
  int k = c / d;
  x *= k;
  y *= k;
  return 1;
}

中国剩余定理

一般这玩意都是用扩展中国剩余定理（模数不互质）

#include<iostream>
#include<vector>
#include<algorithm>
#include<queue>
#include<cstring>
#include<cstdio>
using namespace std;
typedef long long lt;

lt read()
{
    lt f=1,x=0;
    char ss=getchar();
    while(ss<'0'||ss>'9'){if(ss=='-')f=-1;ss=getchar();}
    while(ss>='0'&&ss<='9'){x=x*10+ss-'0';ss=getchar();}
    return f*x;
}

const int maxn=100010;
int n;
lt ai[maxn],bi[maxn];

lt mul(lt a,lt b,lt mod)
{
    lt res=0;
    while(b>0)
    {
        if(b&1) res=(res+a)%mod;
        a=(a+a)%mod;
        b>>=1;
    }
    return res;
}

lt exgcd(lt a,lt b,lt &x,lt &y)
{
    if(b==0){x=1;y=0;return a;}
    lt gcd=exgcd(b,a%b,x,y);
    lt tp=x;
    x=y; y=tp-a/b*y;
    return gcd;
}

lt excrt()
{
    lt x,y,k;
    lt M=bi[1],ans=ai[1];//第一个方程的解特判
    for(int i=2;i<=n;i++)
    {
        lt a=M,b=bi[i],c=(ai[i]-ans%b+b)%b;//ax≡c(mod b)
        lt gcd=exgcd(a,b,x,y),bg=b/gcd;
        if(c%gcd!=0) return -1; //判断是否无解，然而这题其实不用

        x=mul(x,c/gcd,bg);
        ans+=x*M;//更新前k个方程组的答案
        M*=bg;//M为前k个m的lcm
        ans=(ans%M+M)%M;
    }
    return (ans%M+M)%M;
}

int main()
{
    n=read();
    for(int i=1;i<=n;++i)
    bi[i]=read(),ai[i]=read();//读入时看好先读哪个
    printf("%lld",excrt());
    return 0;
}

BSGS

常用来在$O(\sqrt{p})$的时间复杂度内求解$a^x\equiv b\mathrm{m}\mathrm{o}\mathrm{d}p$,其中$a$和$p$互质,方程的解$x$满足$0\le x<p$。
令$x=A\lceil \sqrt{p}\rceil -B$,其中$0\le A,B\le \lceil \sqrt{p}\rceil$,则有$a^{A\lceil \sqrt{p}\rceil -B}\equiv b(\mathrm{m}\mathrm{o}\mathrm{d}p)$，则有$a^{A\lceil \sqrt{p}\rceil }\equiv b{a}^B$.
首先，计算并记录所有$b{a}^B$的取值，再枚举$A$,计算$a^{A\lceil \sqrt{p}\rceil }$是否有$b{a}^B$与之相等，从而可以得到所有的$x$，$x=A\lceil \sqrt{p}\rceil -B$
待补充……

原根

阶

若$(a,m)=1$，使得$a^l\equiv 1(\mathrm{m}\mathrm{o}\mathrm{d}m)$成立最小的$l$，称为$a$关于模$m$的阶，记为$or{d}_{m}a$。
若$or{d}_{m}a=l$,则$or{d}_m{a}^t=\frac{l}{(t,l)}$
由欧拉定理，设$or{d}_{m}a=l$，则$a^n\equiv 1(\mathrm{m}\mathrm{o}\mathrm{d}m)$当且仅当$l|n$,特别地，$l|\phi (m)$.
性质：
1、设$p$是素数，$or{d}_{p}a=l$,那么有且仅有$\phi (l)$个关于模$p$的阶为$l$且两两互不同余的数
2、设$or{d}_{m}a=l$,则$1,a,a^2,\dots ,a^{l-1}$关于模$m$两两互不同余
3、设$p$是素数，$l|p-1$,则存在$\phi (l)$个关于模$p$的阶为$l$且两两互不同余的数。
4、若$m=p_1^{a_1}{p}_2^{a_2}\dots p_k^{a_k}$，则$or{d}_{m}a=[or{d}_{p_1}^{a_1},or{d}_{p_2}^{a_2},\dots ,or{d}_{p_k}^{a_k}]$

原根

$(g,m)=1,$若$or{d}_{m}g=\phi (m)$，则称$g$为$m$的一个原根。
$g$为$m$的一个原根当且仅当{$g,g^2,\dots ,g^{\phi (m)}$}构成模$m$的一个既约剩余系。

是否有原根

若$m$有原根，则$m$一定是：$2,4,p^a,2p^a$，其中$p$是奇素数,$a$为正整数。

求所有原根

设$g$为$m$的一个原根，则集合 S = { g s ∣ 1 ≤ s ≤ φ ( m ) , ( s , φ ( m ) ) = 1 } S=\{g^s|1\le s\le \varphi(m),(s,\varphi(m))=1\} S={gs∣1≤s≤φ(m),(s,φ(m))=1}给出$m$的全部原根。

求一个原根

对$p-1$进行质因数分解得到不同的质因子$d_1,d_2,\dots ,d_m$，对于任意的$1<a<p$，要判定$a$是否是模$p$的原根，只需要检验$a^{\frac{p-1}{d_1}},a^{\frac{p-1}{d_2}},\dots ,a^{\frac{p-1}{d_m}}$这$m$个数中是否存在一个数在模$p$意义下与1同余。若存在，则$a$不是$p$的原根；若不存在，则$a$是$p$的原根。
或者说：$(g,m)=1$，设$p_1,p_2,\dots ,p_k$是$\phi (m)$的所有不同的素因子，则$g$是$m$的原根，当且仅当对任意$1\le i\le k$，都有$g^{\frac{\phi (m)}{p_i}}\not\equiv 1(\mathrm{m}\mathrm{o}\mathrm{d}m)$

注：998244353 的原根是3；1e9+7的原根是5

下面给出暴力求原根的代码：(python版本）

def check(p):
    fac = []
    n = p - 1
    i = 2
    while i * i <= n:
        if n % i == 0:
            fac.append(i)
            while n % i == 0:
                n = n // i
        i += 1
    fac.append(n)
    i = 2
    while i < p:
        flag = True
        for j in fac:
            if pow(i, (p - 1) // j, p) == 1:
                flag = False
                break
        if flag:
            return i
        i += 1


n = int(input())
print(check(n))

卢卡斯定理（大组合数取模）

Lucas定理内容如下：
$C_n^m\mathrm{m}\mathrm{o}\mathrm{d}p=C_{\lfloor \frac{n}{p}\rfloor }^{\lfloor \frac{m}{p}\rfloor }\cdot C_{n\mathrm{m}\mathrm{o}\mathrm{d}p}^{m\mathrm{m}\mathrm{o}\mathrm{d}p}\mathrm{m}\mathrm{o}\mathrm{d}p$

long long Lucas(long long n, long long m, long long p) {
  if (m == 0) return 1;
  return (C(n % p, m % p, p) * Lucas(n / p, m / p, p)) % p;
}

exLucas定理

当模数$p$不是素数时，就需要用到exLucas定理，待补充。。
下面是代码，求$C_n^m\mathrm{m}\mathrm{o}\mathrm{d}p$

#include<bits/stdc++.h>
#define ll long long
using namespace std;
#ifndef Fading
inline char gc(){
    static char now[1<<16],*S,*T;
    if (T==S){T=(S=now)+fread(now,1,1<<16,stdin);if (T==S) return EOF;}
    return *S++;
}
#endif
#ifdef Fading
#define gc getchar
#endif
void exgcd(ll a,ll b,ll &x,ll &y){
    if (!b) return (void)(x=1,y=0);
    exgcd(b,a%b,x,y);
    ll tmp=x;x=y;y=tmp-a/b*y;
}
ll gcd(ll a,ll b){
    if (b==0) return a;
    return gcd(b,a%b); 
}
inline ll INV(ll a,ll p){
    ll x,y;
    exgcd(a,p,x,y);
    return (x+p)%p;
}
inline ll lcm(ll a,ll b){
    return a/gcd(a,b)*b;
}
inline ll mabs(ll x){
    return (x>0?x:-x);
}
inline ll fast_mul(ll a,ll b,ll p){
    ll t=0;a%=p;b%=p;
    while (b){
        if (b&1LL) t=(t+a)%p;
        b>>=1LL;a=(a+a)%p;
    }
    return t;
}
inline ll fast_pow(ll a,ll b,ll p){
    ll t=1;a%=p;
    while (b){
        if (b&1LL) t=(t*a)%p;
        b>>=1LL;a=(a*a)%p;
    }
    return t;
}
inline ll read(){
    ll x=0,f=1;char ch=gc();
    while (!isdigit(ch)) {if (ch=='-') f=-1;ch=gc();}
    while (isdigit(ch)) x=x*10+ch-'0',ch=gc();
    return x*f;
}
inline ll F(ll n,ll P,ll PK){
    if (n==0) return 1;
    ll rou=1;//循环节
    ll rem=1;//余项 
    for (ll i=1;i<=PK;i++){
        if (i%P) rou=rou*i%PK;
    }
    rou=fast_pow(rou,n/PK,PK);
    for (ll i=PK*(n/PK);i<=n;i++){
        if (i%P) rem=rem*(i%PK)%PK;
    }
    return F(n/P,P,PK)*rou%PK*rem%PK;
}
inline ll G(ll n,ll P){
    if (n<P) return 0;
    return G(n/P,P)+(n/P);
}
inline ll C_PK(ll n,ll m,ll P,ll PK){
    ll fz=F(n,P,PK),fm1=INV(F(m,P,PK),PK),fm2=INV(F(n-m,P,PK),PK);
    ll mi=fast_pow(P,G(n,P)-G(m,P)-G(n-m,P),PK);
    return fz*fm1%PK*fm2%PK*mi%PK;
}
ll A[1001],B[1001];
//x=B(mod A)
inline ll exLucas(ll n,ll m,ll P){
    ll ljc=P,tot=0;
    for (ll tmp=2;tmp*tmp<=P;tmp++){
        if (!(ljc%tmp)){
            ll PK=1;
            while (!(ljc%tmp)){
                PK*=tmp;ljc/=tmp;
            }
            A[++tot]=PK;B[tot]=C_PK(n,m,tmp,PK);
        }
    }
    if (ljc!=1){
        A[++tot]=ljc;B[tot]=C_PK(n,m,ljc,ljc);
    }
    ll ans=0;
    for (ll i=1;i<=tot;i++){
        ll M=P/A[i],T=INV(M,A[i]);
        ans=(ans+B[i]*M%P*T%P)%P;
    }
    return ans;
}
signed main(){
    ll n=read(),m=read(),P=read();
    printf("%lld\n",exLucas(n,m,P));
    return 0;
}

数论函数

线性筛法

线性筛法求素数：

void Prime(){
	memset(vis,false,sizeof(vis));
	memset(prime,0,sizeof(prime));
	for(int i=2;i<=maxn;i++){
		if(!vis[i]){
			prime[++cnt]=i;
		}
		for(int j=1;j<=cnt&&i*prime[j]<=maxn;j++){
			vis[i*prime[j]]=true;
			if(i%prime[j]==0){
				break;
			}
		}
	}
}

线性筛法求欧拉函数：

void euler(){
    m = 0;
    memset(v, 0, sizeof(v));
    for(int i = 2; i < maxn; i++){
        if(v[i] == 0){
            v[i] = i;
            p[m++] = i;
            phi[i] = i - 1;
        }
        for(int j = 0; j < m; j++){
            if(p[j] > v[i] || p[j] > maxn / i)
                break;
            v[i * p[j]] = p[j];
            phi[i * p[j]] = phi[i] * (i % p[j] ? p[j] - 1 : p[j]);
        }
    }
}

线性筛法求莫比乌斯函数：

void pre() {
  mu[1] = 1;
  for (int i = 2; i <= 1e7; ++i) {
    if (!v[i]) mu[i] = -1, p[++tot] = i;
    for (int j = 1; j <= tot && i <= 1e7 / p[j]; ++j) {
      v[i * p[j]] = 1;
      if (i % p[j] == 0) {
        mu[i * p[j]] = 0;
        break;
      }
      mu[i * p[j]] = -mu[i];
    }
  }

线性筛法求约数个数：

void pre() {
  d[1] = 1;
  for (int i = 1; i <= n; ++i) {
    if (!v[i]) v[i] = 1, p[++tot] = i, d[i] = 2, num[i] = 1;
    for (int j = 1; j <= tot && i <= n / p[j]; ++j) {
      v[p[j] * i] = 1;
      if (i % p[j] == 0) {
        num[i * p[j]] = num[i] + 1;
        d[i * p[j]] = d[i] / num[i * p[j]] * (num[i * p[j]] + 1);
        break;
      } else {
        num[i * p[j]] = 1;
        d[i * p[j]] = d[i] * 2;
      }
    }
  }
}

线性筛法求约数和：

void pre() {
  g[1] = f[1] = 1;
  for (int i = 2; i <= n; ++i) {
    if (!v[i]) v[i] = 1, p[++tot] = i, g[i] = i + 1, f[i] = i + 1;
    for (int j = 1; j <= tot && i <= n / p[j]; ++j) {
      v[p[j] * i] = 1;
      if (i % p[j] == 0) {
        g[i * p[j]] = g[i] * p[j] + 1;
        f[i * p[j]] = f[i] / g[i] * g[i * p[j]];
        break;
      } else {
        f[i * p[j]] = f[i] * f[p[j]];
        g[i * p[j]] = 1 + p[j];
      }
    }
  }
  for (int i = 1; i <= n; ++i) f[i] = (f[i - 1] + f[i]) % Mod;
}

非常见积性函数的线性筛法

这里主要讨论求两个积性函数狄利克雷卷积的情况，这个函数显然也是积性函数。
设$low(i)$表示$p_1^{a_1}$,对于线性筛法最为关键的$i\%p_j=0$;
有了$low(i)$，我们可以分两种情况来讨论。
1、若$low(i)=i$,此时$i$一定是某个素数的幂次的形式，（否则会被$break$），
此时只要我们可以快速地从$f(p^k)$来更新$f(p^{k+1})$
2、若$low(i)!=i$，此时$i/low(i)$一定与$low(i)\ast p_j$是互质的，
我们可以直接利用积性函数的性质去更新。
下面是伪代码：

vis[1] = low[1] = 1; H[1] = 初始化 
for(int i = 2; i <= N; i++) {
    if(!vis[i]) prime[++tot] = i, mu[i] = -1, H[i] = 质数的情况, low[i] = i;
    for(int j = 1; j <= tot && i * prime[j] <= N; j++) {
        vis[i * prime[j]] = 1;
        if(!(i % prime[j])) {
            low[i * prime[j]] = (low[i] * prime[j]); 
            if(low[i] == i) H[i * prime[j]] = 特殊判断;
            else H[i * prime[j]] = H[i / low[i]] * H[prime[j] * low[i]];
            break;
        } 
        H[i * prime[j]] = H[i] * H[prime[j]];
        low[i * prime[j]] = prime[j];
    }
}

莫比乌斯反演

数论分块

引理1

$\forall a,b,c\in Z,\lfloor \frac{a}{bc}\rfloor =\lfloor \frac{\lfloor \frac{a}{b}\rfloor }{c}\rfloor$

引理2

∀ n ∈ N , ∣ { ⌊ n d ∣ d ∈ N ⌋ } ∣ ≤ ⌊ 2 n ⌋ \forall n\in N,\vert\{\lfloor\frac{n}{d}|d\in N \rfloor\}\vert \leq \lfloor 2\sqrt{n} \rfloor ∀n∈N,∣{⌊dn​∣d∈N⌋}∣≤⌊2n ​⌋
$|V|表示集合V的元素个数$

数论分块

对于含有$\lfloor \frac{n}{i}\rfloor$的求和式子(n为常数)
对于任意一个$i(i\le n)$,我们需要找到一个最大的$j(i\le j\le n)$,使得$\lfloor \frac{n}{i}\rfloor =\lfloor \frac{n}{j}\rfloor .$则有$j=\lfloor \frac{n}{\lfloor \frac{n}{i}\rfloor }\rfloor$.
所以我们可以每次以$[i,j]$为一块，分块求和即可。

积性函数

定义：

$若gcd(x,y)=1且f(xy)=f(x)f(y),则f(n)为积性函数$

性质：

$若f(x)和g(x)均为积性函数，则以下函数也为积性函数：$
$h(x)=f(x^p)$
$h(x)=f^p(x)$
$h(x)=f(x)g(x)$
$h(x)=\sum _{d|x}f(d)g(\frac{x}{d})$

常见积性函数：

$1.幺元函数：ϵ(n)=[n=1]$
$2.常函数：one(x)=1$
$3.标号函数：id(x)=x$
$4.欧拉函数：\phi (n)={\sum }_{i=1}^n[gcd(i,n)=1]$
$5.除数函数：$
$\sigma (k,x)={\sum }_{d|x}{d}^k$
$当k=1时，表示x的因子之和,简记为\sigma (n)$
$当k=0时，表示x的因子个数,简记为d(n)$
\quad k省略时默认为1
$6.莫比乌斯函数：\mu (n)=\{\begin{array}{ll}1& n=1\\ 0& \exists d:d^2|n\\ (-1{)}^{\omega (n)}& otherwise\end{array}$其中$\omega (n)表示n的本质不同的质因子个数，是一个加性函数$

Dirichlet 卷积

定义

$两个数论函数f,g的Dirichlet卷积为(f\ast g)(n)=\sum _{d|n}f(d)g(\frac{n}{d})$

性质

$Dirichlet卷积满足交换律、结合律和分配率.$
$交换律：f\ast g=g\ast f;$
$结合律：(f\ast g)\ast h=f\ast (g\ast h);$
$分配率：(f+g)\ast h=f\ast h+g\ast h;$
$\epsilon 为Dirichlet卷积中的单位元（任何函数卷\epsilon 都是其本身）$

例子

$\epsilon =\mu \ast 1\iff \epsilon (n)=\sum _{d|n}\mu (d)$
$d=1\ast 1\iff d(n)=\sum _{d|n}1$
$\sigma =d\ast 1\iff \sigma (n)=\sum _{d|n}d$
$\phi =\mu \ast id\iff \phi (n)=\sum _{d|n}d\cdot \mu (\frac{n}{d})$
$id=\phi \ast 1\iff n=\sum _{d|n}\phi (d)$
$g=f\ast \mu \iff f=g\ast 1$

莫比乌斯反演

$\mu (n)=\{\begin{array}{ll}1& n=1\\ 0& n含有平方因子\\ (-1{)}^k& k为n的本质不同质因子个数\end{array}$
反演重要结论：
$\epsilon (n)=\sum _{d|n}\mu (d)=[n=1]$
$[gcd(i,j)=1]\iff \sum _{d|gcd(i,j)}\mu (d)$

void getMu() {
  mu[1] = 1;
  for (int i = 2; i <= n; ++i) {
    if (!flg[i]) p[++tot] = i, mu[i] = -1;
    for (int j = 1; j <= tot && i * p[j] <= n; ++j) {
      flg[i * p[j]] = 1;
      if (i % p[j] == 0) {
        mu[i * p[j]] = 0;
        break;
      }
      mu[i * p[j]] = -mu[i];
    }
  }
}

莫比乌斯反演有两种形式：

一、
F(n)=$\sum _{d|n}f(d)\Rightarrow f(n)=\sum _{d|n}\mu (d)F(\frac{n}{d})$
二、
F(n)=$\sum _{n|d}f(d)\Rightarrow f(n)=\sum _{n|d}\mu (\frac{d}{n})F(d)$

例题：

1、Luogu 2303
题意：求$\sum _{i=1}^{N}gcd(i,N),(1\le N\le 2^{32})$
解法：$\sum _{i=1}^{N}gcd(i,N)=\sum _{d|N}d\sum _{i=1}^N[gcd(i,N)=d]=\sum _{d|N}d\sum _{i=1}^{\lfloor \frac{N}{d}\rfloor }[gcd(i,\lfloor \frac{N}{d}\rfloor )=1]=\sum _{d|N}d\phi (\lfloor \frac{N}{d}\rfloor )$
2、求$\sum _{i=1}^n\sum _{j=1}^m[gcd(i,j)=1]$
解法：$\sum _{i=1}^n\sum _{j=1}^m[gcd(i,j)=1]=\sum _{i=1}^n\sum _{j=1}^m\sum _{d|gcd(i,j)}\mu (d)=\sum _{d=1}^{min(n,m)}\mu (d)\lfloor \frac{n}{d}\rfloor \lfloor \frac{m}{d}\rfloor$

杜教筛

问题：求积性函数$f(i)$的前缀和$\sum _{i=1}^{n}f(i)$
构造两个积性函数$h,g$，使得$h=f\ast g$
$\sum _{i=1}^{n}h(i)=\sum _{i=1}^n\sum _{d|i}g(d)f(\frac{i}{d})$
$=\sum _{d=1}^{n}g(d)\sum _{i=1}^{\lfloor \frac{n}{d}\rfloor }f(i)$
$\sum _{i=1}^{n}h(i)=\sum _{i=1}^{n}g(d)S(\lfloor \frac{n}{d}\rfloor )$
$\sum _{i=1}^{n}h(i)=g(1)S(n)+\sum _{d=2}^{n}g(d)S(\lfloor \frac{n}{d}\rfloor )$
$g(1)S(n)=\sum _{i=1}^{n}h(i)-\sum _{d=2}^{n}g(d)S(\lfloor \frac{n}{d}\rfloor )$
$构造出的h(i)要使得\sum _{i=1}^{n}h(i)能较快的求出来，$
$先用线性筛把前m项筛出来，当m=n^{\frac{2}{3}}时，复杂度为O(n^{\frac{2}{3}});$
$当m=n^{\frac{1}{2}}时，复杂度为O(n^{\frac{3}{4}});$

ll GetSum(int n){//f的前缀和
	if(n<=1000000)return sum[n];//线性筛预处理
	if(mp[n]!=0)return mp[n];//记忆化
	ll ans = f_g_sum(n)%mod; //h的前缀和
	for(ll l = 2, r; l <= n; l = r + 1) { //整除分块
		r = (n / (n / l)); 
		ans = (ans - (g_sum(r) - g_sum(l - 1)) * GetSum(n / l) + mod)%mod;
		//g_sum是g的前缀和，GetSum递归求
	}
	mp[n]=ans;
	return ans; 
}

Min_25筛

前提：一个积性函数$f(i)$,且$f(p)$是一个关于$p$的项数较少的多项式或可以快速求值；即$f(p^c)$可以快速求值。
用法：在$O(\frac{n^{\frac{3}{4}}}{\log n})$的时间复杂度下求$\sum _{i=1}^{n}f(i)$
一些定义：
$p_k$:第$k$个质数，特别地，令$p_0=1$。
$lpf(n):$为$n$的最小质因子，特别地，令$lpf(1)=1$
$F_{prime}(n):={\sum }_{2\le p\le n}f(p)$
$F_k(n):=\sum _{i=2}^n[p_k\le lpf(i)]f(i)$
根据定义：可以发现$\sum _{i=1}^{n}f(i)=F_1(n)+f(1)$
$\begin{array}{rlr}{F}_k(n)& =\sum _{i=2}^n[p_k\le lpf(i)]f(i)& ①\\ & =\sum _{k\le i,p_i\le n}f(p_i)+\sum _{k\le i,p_i^2\le n}\sum _{c\ge 1,p_i^c\le n}f(p_i^c)([c>1]+F_{i+1}(\frac{n}{p_i^c}))& ②\\ & =F_{prime}(n)-F_{prime}(p_{k-1})+\sum _{k\le i,p_i^2\le n}\sum _{c\ge 1,p_i^c\le n}f(p_i^c)([c>1]+F_{i+1}(\frac{n}{p_i^c}))& ③\\ & =F_{prime}(n)-F_{prime}(p_{k-1})+\sum _{k\le i,p_i^2\le n}\sum _{c\ge 1,p_i^{c+1}\le n}(f(p_i^c)F_{i+1}(\frac{n}{p_i^c})+f(p_i^{c+1}))& ④\end{array}$
$②$推导：枚举素因子$p_i$,前面部分不解释了，后面部分是$p_i$作为最小素因子时的合数，考虑合数中$p_i$出现了$c$次，$F_{i+1}(\frac{n}{p_i^c})$即是剩余部分，因为剩余部分最小的质因子也要大于$p_i$，所以从$p_{i+1}$开始。
$③$推导是傻子问题，不解释了。
$④$推导：对于满足$p_i^c\le n<p_i^{c+1}$的$c$，有$p_i^{c+1}>n⟺\frac{n}{p_i^c}<p_i<p_{i+1}$,所以$F_{i+1}(\frac{n}{p_i^c})=0$；
然后又有$\sum _{c\ge 1,p_i^{c+1}\le n}f(p_i^{c+1})=\sum _{c\ge 1,p_i^c\le n}f(p_i^c)[c>1]$,其边界值为$F_k(n)=0(p_k>n)$。
那假设现在已经求出了所有的$F_{prime}(n)$，那么有两种方式可以求出所有的$F_k(n)$：
1.直接按照递推式计算。（一般数据不是特别大的话用这个）
2.从大到小枚举$p$的转移，仅当$p^2<n$时转移增加值不为0，按照递推式后缀和优化即可。
如何计算$F_{prime}(n)$呢？
容易发现$F_{prime}$有且仅有$1,2,\dots ,\lfloor \sqrt{n}\rfloor ,\frac{n}{\sqrt{n}},\dots ,\frac{n}{2},n$处的值是有用的。
Min_25可用的前提是$f(p)$是一个关于$p$的低次多项式，可以表示为$f(p)=\sum a_i{p}^{c_i}$,那么每个$p_{c_i}$对$F_{prime}(n)$的贡献是$a_i{\sum }_{2\le p\le n}{p}^{c_i}$。
问题就转变成了：给定$n,s,g(p)=p^s$
构造一个新的函数$G_k(n)=\sum _{i=1}^n[p_k<lpf(i)|isprime(i)]g(i)$。
对于一个合数$x$，必定有$lpf(x)\le \sqrt{x}$，则$F_{prime}(n)=G_{\lfloor \sqrt{n}\rfloor }$(n),因为不存在$lpf(i)>p_{\lfloor \sqrt{n}\rfloor }$。
考虑G的边界值，有$G_0(n)=\sum _{i=2}^{n}g(i),p_0=1$。
对于转移，有：
对于$n<p_k^2$的部分，$G_k(n)=G_{k-1}(n)$。
对于$p_k^2\le n$的部分，被筛掉的数必有质因子$p_k$，即$-g(p_k)G_{k-1}(\frac{n}{p_k})$；但是会有$lpf(i)<p_k$的$i$被减去，应该加回来，即$g(p_k)G_{k-1}(p_{k-1})$。
所以，有：$G_k(n)=G_{k-1}(n)-[p_k^2\le n]g(p_k)(G_{k-1}(\frac{n}{p_k})-G_{k-1}(p_{k-1}))$
代码实现方案：
对于$F_{prime}(n)$，直接按照递推式实现；
对于$p_k^2\le n$，可以用线性筛预处理$s_k=F_{prime}(p_k)$来代替$F_k$递推式中的$F_{prime}(p_{k-1})$。$G$递推式中的$G_{k-1}(p_{k-1})={\sum }_{i=1}^{k-1}g(p_i)$也可以预处理。
使用Min_25时，首先要明确：
如何线性筛出前$\sqrt{n}$个$f$值；
$f(p)$的多项式表示；
如何快速求出$f(p^c)$。
然后按照顺序实现：
1、筛出$[1,\sqrt{n}]$内的质数与前$\sqrt{n}$个$f$值；
2、对$f(p)$多项式表示中的每一项筛出对应的$G$,合并得到$F_{prime}$的所有$O(\sqrt{n})$个有用点值；
3、按照$F_k$的递推式实现递归，求出$F_1(n)$。
以下模板以dengtesla大佬的模板进行地修改（完全是因为码风不同，所以改的），大佬模板链接dengtesla大佬的Min_25模板

#include<bits/stdc++.h>
#define ll long long
using namespace std;

const int maxn = 2000;
const int N = 710000;
const int mod = 1e9+7;

int b[maxn+1],c[maxn+1][maxn+1],Inv[maxn+1];
ll sqr,n; /// sqr为sqrt(n)
ll w[N],id1[N],id2[N];
///w[i]记录了形如n/k的第i大的取值是多少

int tot; ///记录对于要筛的n,sqrt(n)以内质数的个数
int isp[N],p[N];
ll zh[N][3]; ///zh[i][k]记录(p[1])^k + (p[2])^k + ... + (p[i])^k
ll g[N][3];
///这个k要根据题目改范围，就是这个3要改成多项式的最高次幂
ll qpow(ll a,ll b){
    ll ans=1;
	a=a%mod;
    while(b){
        if(b&1)
            ans=ans*a%mod;
        a=a*a%mod;
        b>>=1;
    }
    return ans;
}


ll sigma_f(ll n,int k){ ///得到∑i^k, i:1~n
    if(k==0) return n;
    n++;
    n%=mod;
    ll tmp = n;
    ll ans=0;
    for (int i=1;i<=k+1;i++){
        ans += 1LL*c[k+1][i]*b[k+1-i]%mod*n%mod;
        ans %= mod;
        n *= tmp%mod;
        n %= mod;
    }
    ans = ((ans*Inv[k+1])%mod+mod)%mod;
    return ans;
}

void get_p(int n,int w){
    tot = 0;
    memset(isp,1,sizeof(isp));
    isp[0] = 0;
    isp[1] = 0;
    for(int i=2;i<=n;i++){
        if(isp[i]){
            p[++tot] = i;
            ll wait = 1;
            for(int j=0;j<=w;j++){
                zh[tot][j] = zh[tot-1][j] + wait;
                zh[tot][j] %= mod;
                wait *= i;
            }
        }
        for(int j=1;p[j]*i<=n&&j<=i;j++){
            isp[i*p[j]] = 0;
            if(i%p[j]==0) break;
        }
    }
}

void get_g(ll n,int t){
///对每个x=n/i,求出∑[i是质数](i^t) (i from 1 to x)。每个对应的值存储在g[x][t]中
    int m = 0;
    ll i=1,r;
    while(i<=n){
        ll len = n/i;
        r = n/len;
        if(len<=sqr) id1[len] = ++m;
        else id2[r] = ++m;
        for(int ww=0;ww<=t;ww++){
            g[m][ww] = sigma_f(len,ww)-1;
            g[m][ww] %= mod;
            g[m][ww] += mod;
            g[m][ww] %= mod;
        }
        w[m] = len; ///w[i]记录了形如n/k的第i大的取值是多少
        i = r+1;
    }
    for(int i=1;i<=tot;i++){
        for(int j=1;j<=m;j++){
            if(1LL*p[i]*p[i]>w[j]) break;
            else{
                int op;
                if(w[j]/p[i]<=sqr) op = id1[w[j]/p[i]];
                else op = id2[n/(w[j]/p[i])];
                for(int ww=0;ww<=t;ww++){
                    g[j][ww] = g[j][ww] - qpow(p[i],ww)*((g[op][ww]-zh[i-1][ww])%mod);
                    g[j][ww] %= mod;
                    g[j][ww] += mod;
                    g[j][ww] %= mod;
                }
            }
        }
    }
}

inline ll get_value(int wz,int k){
    ll w = (g[wz][2]+2*g[wz][1]-g[wz][0])-(zh[k-1][2]+2*zh[k-1][1]-zh[k-1][0]);
    w %= mod;
    w += mod;
    w %= mod;
    ///比如f(x) = x - 1,
    ///ll w = (g[wz][1]-g[wz][0])-(zh[k-1][1]-zh[k-1][0]);
    return w; ///自己填写f(x)的表达式（在质数时）
    ///比如f(x) = x^2 + 2*x - 1,
    ///就写(g[wz][2]+2*g[wz][1]-g[wz][0])-(zh[k-1][2]+2*zh[k-1][1]-zh[k-1][0])
}

ll f(ll p,ll k){ ///计算f(p^k)处的值
    if(p==1) return f(1)%mod;//f(1)的值
    else if(k==1) return ...%mod;
    return ...%mod; ///自己填写
}

ll get_s(ll x,int k){
    if(x<=1||p[k]>x) return 0;
    int wz;
    if(x<=sqr) wz = id1[x];
    else wz = id2[n/x];
    ll ans = get_value(wz,k);
    //if(k==1) ans += 2;
    for(int i=k;i<=tot&&1LL*p[i]*p[i]<=x;++i){
        for(ll l=p[i],e=1;l*p[i]<=x;l=l*p[i],++e){
            ans = ans + (get_s(x/l,i+1)*f(p[i],e)%mod)%mod+f(p[i],e+1);
            ans %= mod;
        }
    }
    ans += mod;
    ans %= mod;
    return ans;
}

void init(){
    c[0][0]=1;
    for (int i=1;i<maxn;i++){//求组合数
        for (int j=1;j<=i;j++) 
            c[i][j]=(c[i-1][j-1]+c[i-1][j]) % mod;
        c[i][0]=1;
    }
    Inv[1]=1;//线性求逆元
    for (int i=2;i<maxn;i++) 
        Inv[i]=1LL*Inv[mod % i] * (mod-mod/i) % mod;
    b[0]=1;
    for (int i=1;i<maxn;i++){//伯努利数
        b[i]=0;
        for (int k=0;k<i;k++) 
            b[i]=(b[i]+1LL*c[i+1][k]*b[k] % mod) % mod;
        b[i]=(1LL*b[i]*(-Inv[i+1]) % mod+mod)%mod;
    }
}

void solve(ll n){   
    sqr = sqrt(n);
    get_p(sqr,2);
    get_g(n,2);
    ll ans = get_s(n,1)+f(1,1);
    cout << ans << endl;
}

int main(){
    init();
    while(cin >> n){
        solve(n);
    }
}

代码中的一些说明:
求$\sum _{i=1}^n{i}^k$时用了伯努利数，即生成函数。
有$\sum _{i=1}^n{i}^k=\frac{\sum _{j=0}^k(-1{)}^j{C}_{k+1}^j{B}_j{n}^{k+1-j}}{k+1}$,其中$B_j$是伯努利数。
$B_n=[n=0]-\sum _{k=0}^{n-1}{C}_{n+1}^k\frac{B_k}{n+1}$,且$B_0=1$。