数论学习笔记1之积性函数与线性筛求积性函数

一、积性函数

1.1 定义

积性函数又称为乘性函数，在数论中有很多这样的函数。
定义在所有正整数上的函数称为算术函数。

$$\begin{array}{rl}& 而对于任意算术函数f如果满足任意两个互质的正整数n和m\\ & 均有f(mn)=f(m)f(n)，则称f为积性函数，或者：\\ & f为积性函数当且仅当gcd(m,n)=1且f(mn)=f(m)f(n)\\ & \\ & 此外，给出完全积性函数的定义：\\ & 对于任意正整数n,m，均有f(mn)=f(m)f(n)，则称f为完全积性函数\end{array}$$

1.2 定理

定理1：
$$\begin{array}{rl}& 如果f是积性函数，对于n有算数基本定理:\\ & n=p_1^{a_1}{p}_2^{a_2}...p_k^{a_k},再由积性函数性质：\\ & 则f(n)=f(p_1^{a_1}{p}_2^{a_2}...p_k^{a_k})\\ & =f({p_1}^{a_1})f(p_2^{a_2})...f(p_k^{a_k})\end{array}$$

1.3 常见的积性函数

$$id,d,\phi ,\delta ,I,\mu ,ϵ$$
$$\begin{array}{rl}& id:单位函数（恒等函数），定义为id(n)=n（完全积性）\\ & d:除数函数（约数个数函数)，d(i)=\sum _{d|N}1\\ & \phi :1-n中与n互质的数的个数,\phi (i)=i\cdot \prod _{i=1}^{p_k}(1-\frac{1}{p_i})\\ & \delta :约数和函数,\delta (i)=\sum _{d|N}d\\ & I:不变函数:I(i)=1\\ & \mu :莫比乌斯函数：对于\mu (i):\\ & 当i=1时，\mu (i)=1\\ & 当i分解质因数后，所有质因数的指数只要有1个\ge 2,则\mu (i)=0\\ & 否则,\mu (i)=(-1{)}^k,k即是质因数的个数\\ & ϵ:单位元函数，ϵ(i)=[n=1],[n=1]表示只有当n=1时,该值为1，其他n的取值均使[n=1]=0\\ & [n=1]这种属于真值函数，如果说括号内条件成立，那么才会对和式有贡献\\ & 常见的还有[gcd(i,j)=1]\end{array}$$

1.4 狄利克雷卷积

$$\begin{array}{rl}& 这里给出普通卷积的定义和狄利克雷卷积的定义\\ & 读者观察即可清楚他们的区别\\ & (f\ast g)(n)表示f卷积g的第n项\\ & \\ & 普通卷积：(f\ast g)(n)=\sum _{i+j=n}f(i)g(n-i)\\ & 狄利克雷卷积(f\ast g)(n)=\sum _{i\cdot j=n}f(i)g(\frac{n}{i})\\ & 狄利克雷卷积的常见形式：\\ & (f\ast g)(n)=\sum _{d|n}f(d)g(\frac{n}{d})\end{array}$$

1.4.1 狄利克雷卷积的性质

1.交换律
$$(f\ast g)(n)=(g\ast f)(n)$$
2.结合律
$$(f\ast g\ast h)(n)=(f\ast (g\ast h))(n)$$
3. 分配律：$$f\ast (g+h)=f\ast g+f\ast h$$
4. 卷积单位元：$$\begin{gathered} f\ast ϵ=f \\ 类似a\cdot 1=a \end{gathered}$$
5. 逆元：$$如果f\ast g=ϵ,则g是f的逆元$$
6. $$若函数f,g为积性函数，则f\ast g也为积性函数$$

1.4.2 常见积性函数的卷积

(1) $$\mu \ast I=ϵ\ast I=I\ast I=d$$
(2) $$\phi \ast I=id\ast I=\delta$$
(3) $$i{d}^k\ast I={\delta }^k$$
或者记

1.4.5 狄利克雷卷积的代码实现

//f*g O(nlogn)
void Dirichlet(ll *f, ll *g)
{
	int h[N] = {0};
	for(int i = 1; i <= n; ++ i) {
		for(int j = i; j <= n; j += i) {
			h[j] = (h[j] + f[i] * g[j / i]) % mod;
		}
	}
	for(int i = 1; i <= n; ++ i) 
		f[i] = h[i]; 
}  

二、线性筛求积性函数

2.1 前置知识

前言：线性筛积性函数的四个常见积性函数的筛法可以反复揣摩

线性筛：在O(n)时间复杂度内筛素数或者积性函数的东西。
任意积性函数均可以线性筛。
线性筛求积性函数一般就预处理N=1e7的数据，如果N=1e9就会超时了，考虑使用杜教筛，
但是依然要用线性筛预处理5e6左右的数据，这样能够加快杜教筛的速度。

2.2 线性筛素数

保证每个数只会被它的最小质因子给筛掉:

code:

void get_primes()
{
    for(int i = 2;i<=n;i++)
    {
        if(!st[i])
        {
            primes[cnt++] = i;
        }
        for(int j = 0;primes[j]<=n/i;j++)
        {
            st[primes[j]*i] = true;
            if(i%primes[j]==0) break;
        }
    }
}

2.3 线性筛欧拉函数

const int N = 1e7+10;
bool st[N];
typedef long long ll;
ll primes[N],cnt,phi[N];
int n;
void get_phi(int n)
{
    phi[1] = 1;
    for(int i = 2;i<=n;i++)
    {
        if(!st[i])
        {
            phi[i] = i-1;
            primes[cnt++] = i;
        }
        for(int j = 0;j<cnt&&i*primes[j]<=n;j++)
        {
            st[i*primes[j]] = true;
            if(i%primes[j]==0)
            {
                phi[i*primes[j]] = phi[i]*primes[j];
                break;
            }
            else
            {
                phi[i*primes[j]] = phi[i]*phi[primes[j]];
            }
        }
    }
}

2.4 线性筛莫比乌斯函数

const int N = 1e7+10;
bool st[N];
typedef long long ll;
int primes[N],cnt,mu[N];
int n;
void get_mu(int n)
{
    mu[1] = 1;
    for(int i = 2;i<=n;i++)
    {
        if(!st[i])
        {
            mu[i] = -1;
            primes[cnt++] = i;
        }
        for(int j = 0;j<cnt&&i*primes[j]<=n;j++)
        {
            st[i*primes[j]] = true;
            if(i%primes[j]==0)
            {
                mu[i*primes[j]] = 0;
                break;
            }
            else
            {
                mu[i*primes[j]] = mu[i]*mu[primes[j]];
            }
        }
    }
}

2.5 线性筛约数个数函数

const int N = 1e7+10;
bool st[N];
typedef long long ll;
ll primes[N],cnt,d[N],deg[N];
int n;
void get_d(int n)
{
    d[1] = 1,deg[1] = 1;
    for(int i = 2;i<=n;i++)
    {
        if(!st[i])
        {
            d[i] = 1+1,deg[i] = 1+1;
            primes[cnt++] = i;
        }
        for(int j = 0;j<cnt&&i*primes[j]<=n;j++)
        {
            st[i*primes[j]] = true;
            if(i%primes[j]==0)
            {
                d[i*primes[j]] = d[i]/deg[i]*(deg[i]+1);
                deg[i*primes[j]] = deg[i]+1;
                break;
            }
            else
            {
                d[i*primes[j]] = d[i]*2;
                deg[i*primes[j]] = 1+1;
            }
        }
    }
}

2.6 线性筛约数和函数

const int N = 1e7+10;
bool st[N];
typedef long long ll;
ll primes[N],cnt,delta[N],deg[N];
int n;
void get_delta(int n)
{
    delta[1] = 1,deg[1] = 1;
    for(int i = 2;i<=n;i++)
    {
        if(!st[i])
        {
            delta[i] = 1+i,deg[i] = 1+i;
            primes[cnt++] = i;
        }
        for(int j = 0;j<cnt&&i*primes[j]<=n;j++)
        {
            st[i*primes[j]] = true;
            if(i%primes[j]==0)
            {
                delta[i*primes[j]] = delta[i]*primes[j]+delta[i]/deg[i];
                deg[i*primes[j]] = deg[i]*primes[j]+1;
                break;
            }
            else
            {
                delta[i*primes[j]] = delta[i]*(1+primes[j]);
                deg[i*primes[j]] = 1+primes[j];
            }
        }
    }
}

2.7 线性筛一般积性函数

筛常见积性函数和筛一般积性函数的方式是一样的：这里尽量给出一般积性函数的线性筛法与模板。

$$\begin{array}{rl}& 1.先求出f(1)\end{array}$$

类似mu[1] = 1,phi[1] = 1,d[1] = 1,delta[1] = 1,f(1)是很好求的

$$\begin{array}{rl}& 2.初始化f(p)(p是质数)\end{array}$$

for(int i = 2;i<=n;i++)
{
	if(!st[i])
	{
		//说明i是质数
		primes[cnt++] = i;
		f[i] = ?//根据积性函数不同而不同
	}
}

$$\begin{array}{rl}& 3.在筛的时候，我们知道primes[j]一定是i\ast primes[j]的最小质因子,\\ & 然后对于i有算数基本定理得到p_1^{a_1}{p}_2^{a_2}...p_k^{a_k}\\ & 易有两种情况：\\ & [1]primes[j]=p_1即(i\%primes[j]==0)\\ & [2]primes[j]<p_1即(i\%primes[j]!=0)\\ & (1)对于第一种情况，显然i\ast primes[j]的质因子和i的质因子是一样的\\ & 只有最小质因子的指数比i的多1，即\\ & {p_1}_{(i\cdot primes[j])}={p_1}_{(i)}+1\\ & (2)对于第二种情况，显然primes[j]<p_1,故primes[j]一定是与i互质的\\ & 不妨设要求的积性函数为f,则f(i\cdot primes[j])=f(i)\cdot f(primes[j])\\ & (3)第一种情况里f(i\cdot primes[j])怎么求呢？\\ & 这就要引入线性筛求约数个数函数和求约数和函数里\\ & deg数组的作用，例如约数个数函数d，\\ & 易有d(i)=(a_1+1)(a_2+1)...(a_k+1)\\ & 那么d(i\ast primes[j])=(a_1+1+1)(a_2+1)...(a_k+1)\\ & 对于约数个数函数有deg[i]表示最小质因数的指数+1，即deg[i]=(a_1+1)\\ & 那么d(i\ast primes[j])就好求了,首先i\%primes[j]==0使得\\ & deg[i\ast primes[j]]=deg[i]+1\\ & 再考虑d[i\ast primes[j]]=d[i]/deg[i]\ast deg[i\ast primes[j]];\\ & 建议读者在纸上演算一下，就很明了了。\end{array}$$

2.7.1 模板

一般地，可以写出线性筛一般积性函数的模板~

const int N = 1e7+10;
bool st[N];
typedef long long ll;
ll primes[N],cnt,f[N],f_deg[N];
//f_deg即是存放和最小质因子相关的一项
//在约数个数函数里f_deg = (a1+1)
//在约数和函数里f_deg = 1+p0^1+p0^2+...p0^n
int n;
void get_f(int n)
{
    f[1] = ?,f_deg[1] = ?;
    for(int i = 2;i<=n;i++)
    {
        if(!st[i])
        {
            f[i] = ?;f_deg[i] = ?;
            primes[cnt++] = i;
        }
        for(int j = 0;j<cnt&&i*primes[j]<=n;j++)
        {
            st[i*primes[j]] = true;
            if(i%primes[j]==0)
            {
                f[i*primes[j]] = ?;
                f_deg[i*primes[j]] = ?
                break;
            }
            else
            {
                f[i*primes[j]] = f[i]*f[primes[j]];//由积性函数性质
                f_deg[i*primes[j]] = ?;
            }
        }
    }
}