欧拉函数、莫比乌斯函数、杜教筛

积性函数

1、积性函数：任意互素的两个数m、n，满足f(mn)=f(m)f(n)
常见积性函数：$\phi ,\mu ,\sigma ,d$
φ：欧拉函数
μ：莫比乌斯函数
d：约束个数函数 $d={\sum }_{d|n}1$
σ：约束和函数 $\sigma (n)={\sum }_{d|n}d$

2、完全积性函数：任意两个数m、n，满足f(mn)=f(m)f(n)
常见完全积性函数：$ϵ,I,id$
$ϵ$：元函数 $ϵ(n)=[n=1]$
$I$：恒等函数$I(n)=1$
$id$：单位函数 $id(n)=n$

狄利克雷卷积

定义：两个数论函数 f 和 g 的卷积为 $(f\ast g)(n)={\sum }_{d|n}f(d)g(\frac{n}{d})$
性质：和乘法差不多，满足交换律、结合律、分配律
1、交换律：交换的顺序，只是枚举的约数的顺序出现变化，每个约数的贡献不变
2、元函数：$f\ast ϵ=f$

欧拉函数

定义：$\phi (n)$指小于等于n且与n互素的正整数的个数
公式：$\phi (n)=n{\prod }_{i=1}^k(1-\frac{1}{p_i})$，k为不同的质因子的个数
性质：
1、当n>2时，$\phi (n)$为偶数
2、当n>1时，小于n的数中与n互质的数的总和是：$\frac{\phi (n)n}{2}$
3、n的所有因子的欧拉函数之和等于n：${\sum }_{d|n}\phi (d)=n$

欧拉函数的三种求法

1、直接求欧拉函数，也可以先筛出素数，然后用素数去化简

ll euler(ll n)
{
	ll ret=n,a=n;
	for(ll i=2;i*i<=a;++i)
	{
		if(a%i==0)
		{
			ret=ret/i*(i-1);
			while(a%i==0)
				a/=i;
		}
	}
	if(a>1)
		ret=ret/a*(a-1);
	return ret;
}

2、埃氏筛

int phi[maxn]; 
void euler(int n)
{
	for(int i=1;i<=n;++i)
		phi[i]=i;
	for(int i=2;i<=n;++i)
	{
		//相等表示i是质数。不相等，说明是合数，已经被更新过了 
		if(phi[i]==i)
		{
			//遍历i的倍数，i是质因子，据公式更新 
			for(int j=i;j<=n;j+=i)
				phi[j]=phi[j]/i*(i-1);	
		}
	}
}

3、欧拉筛求欧拉函数

const int N=1e5;
int visit[N+10],phi[N+10],prime[N+10],cnt;

void euler()
{
	phi[1]=1,cnt=0;		//1要特判 
	for (int i=2;i<=N;i++)
	{
		if(!visit[i])		//这代表i是质数
		{
			prime[++cnt]=i;
			phi[i]=i-1;
		}
		for (int j=1;j<=cnt&&prime[j]*i<=N;j++)	 
		{
			visit[i*prime[j]]=1;		//把这个合数标记掉 
			if (i%prime[j]==0)
			{
			//若prime[j]是i的质因子，据计算公式，i已经包括i*prime[j]的所有质因子
				phi[i*prime[j]]=phi[i]*prime[j]; 
				break;	//break用于这样能保证每个数只会被自己最小的因子筛掉一次 
			}
			else  //与质数不是倍数关系，就是互质 
				phi[i*prime[j]]=phi[i]*phi[prime[j]];	//积性函数 
		}
	}
}

不带注释

const int N=1e5;
int visit[N+10],phi[N+10],prime[N+10],cnt;

void euler()
{
	phi[1]=1,cnt=0;		
	for (int i=2;i<=N;i++)
	{
		if(!visit[i])		
		{
			prime[++cnt]=i;
			phi[i]=i-1;
		}
		for (int j=1;j<=cnt&&prime[j]*i<=N;j++)	 
		{
			visit[i*prime[j]]=1;		
			if (i%prime[j]==0)
			{
				phi[i*prime[j]]=phi[i]*prime[j]; 
				break;	
			}
			else phi[i*prime[j]]=phi[i]*phi[prime[j]];	
		}
	}
}

莫比乌斯函数

定义：每一个n可以分解为：$n=p_1^{k_1}{p}_2^{k_2}\dots p_s^{k_s}$
$$\mu (n)=\{\begin{array}{ll}1& (n=1)\\ 0& (\exists k_i\ge 2)\\ (-1{)}^s& (\forall k_i=1)\end{array}$$

性质：
1、${\sum }_{d|n}u(d)=[n=1]$
2、${\sum }_{d|n}\mu (d)\frac{n}{d}=\phi (n)$
证明：利用欧拉函数的性质：${\sum }_{d|n}\phi (d)=n$
写成卷积形式：$\phi \ast I=id$
化简：$\phi \ast I\ast \mu =id\ast \mu$ $⟶$$\phi \ast ϵ=id\ast \mu$
$\phi (n)={\sum }_{d|n}u(d)id(\frac{n}{d})={\sum }_{d|n}u(d)\frac{n}{d}$

线性筛莫比乌斯函数

const int N=5e4+5;
int prime[maxn],visit[maxn];
int mu[maxn],cnt;

void Mobius()
{
	memset(visit,0,sizeof(visit));
	memset(mu,0,sizeof(mu));
	cnt=0,mu[1]=1,visit[1]=1;
	for(int i=2;i<N;++i)
	{
		if(!visit[i])
			prime[++cnt]=i,mu[i]=-1;
		for(int j=1;j<=cnt&&i*prime[j]<N;++j)
		{
			visit[i*prime[j]]=1;
			if(i%prime[j]==0)
				break;
			mu[i*prime[j]]=-mu[i];
		}			
	}	
}

莫比乌斯反演

形式一：设f(n)是一个任意的函数，$F(n)={\sum }_{d|n}f(d)$
反演可得:$$f(n)=\sum _{d|n}\mu (d)F(\frac{n}{d})$$

证明：$F(n)={\sum }_{d|n}f(d)=f\ast I=$
$F\ast \mu =f\ast I\ast \mu =f\ast (I\ast u)$
利用性质：${\sum }_{d|n}u(d)=[n=1]$
因此： $I\ast \mu =ϵ$
$$f\ast (I\ast \mu )=f\ast ϵ=f=F\ast \mu =\sum _{d|n}u(d)F(\frac{n}{d})$$

形式二：设f(n)是一个任意的函数，$F(n)={\sum }_{n|d}f(d)$
反演可得：$$f(n)=\sum _{n|d}\mu (\frac{d}{n})F(d)$$

杜教筛

用途：计算积性函数的前缀和，时间复杂度为$O(n^{\frac{2}{3}})$
1、需要计算：${\sum }_{i=1}^{n}f(i)$
2、构造两个积性函数h和g满足：$h=f\ast g$
3、推导：先计算${\sum }_{i=1}^{n}h(i)$，设$S(n)$为$f(i)$前缀和

$$\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}^{\frac{n}{d}}f(i)$$

$$=\sum _{d=1}^{n}g(d)S(\frac{n}{d})$$

$$=g(1)S(n)+\sum _{d=2}^{n}g(d)S(\frac{n}{d})$$

因此可得：
$$g(1)S(n)=\sum _{i=1}^{n}h(i)-\sum _{d=2}^{n}g(d)S(\frac{n}{d})$$

例一：求$S(n)={\sum }_{i=1}^n\mu (i)$
我们很容易想到：$\mu \ast I=ϵ$，对$ϵ$求求前缀和就是1
$$g(1)S(n)=\sum _{i=1}^{n}h(i)-\sum _{d=2}^{n}g(d)S(\lfloor \frac{n}{d}\rfloor )$$
该式可以化简为：
$$S(n)=1-\sum _{d=2}^{n}S(\lfloor \frac{n}{d}\rfloor )$$

例二：求$S(n)={\sum }_{i=1}^n\phi (i)$
我们知道： $\phi \ast I=id$
因此同样可以化简为：
$$S(n)=\sum _{i=1}^{n}i-\sum _{d=2}^{n}S(\lfloor \frac{n}{d}\rfloor )$$

例三：求$S(n)={\sum }_{i=1}^{n}i\times \phi (i)$
（1）我们观察：$f(i)=i\times \phi (i)$
（2）然后考虑：$f\ast g$的卷积形式：$h=f\ast g={\sum }_{d|n}d\times \phi (d)g(\frac{n}{d})$
（3）很明显，我们想要消去这个d，因此取g=id
化简： $h={\sum }_{d|n}d\times \phi (d)\frac{n}{d}={\sum }_{d|n}n\times \phi (d)=n^2$
（4）因此可以得到：
$$S(n)=\sum _{i=1}^n{i}^2-\sum _{d=2}^{n}S(\lfloor \frac{n}{d}\rfloor )$$

P4213 【模板】杜教筛（Sum）

题意：求欧拉函数和莫比乌斯函数的前缀和
分析：模板题。需要使用：快读、unordered_map记忆化、整除分块不能全用long long

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <queue>
#include <vector>
#include <set>
#include <map>
#include <unordered_map>
#include <cstring>
#include <string>
#include <cmath>
#define rep(i,a,b) for (int i=a; i<=b; ++i)
#define per(i,b,a) for (int i=b; i>=a; --i)
#define mes(a,b)  memset(a,b,sizeof(a))
#define mp make_pair
#define ll long long
#define pb push_back
#define pii pair<int,int>
#define pll pair<ll,ll>
#define ls (rt<<1)
#define rs ((rt<<1)|1)
#define isZero(d)  (abs(d) < 1e-8)
using namespace std;
const int maxn=6e6+10,INF=0x3f3f3f3f;
const int mod=1e9+7;

inline int read() 
{
    int X=0,w=1; 
	char c=getchar();
    while (c<'0'||c>'9') 
	{ 
		if (c=='-') w=-1; 
		c=getchar(); 
	}
    while (c>='0'&&c<='9') 
		X=X*10+c-'0',c=getchar();
    return X*w;
}

int T,n;

const int N=6e6;
ll phi[maxn];
int visit[maxn],prime[maxn],mu[maxn],cnt;

inline void init()
{
	mu[1]=1,phi[1]=1,cnt=0;
	for(int i=2;i<=N;++i)
	{
		if(!visit[i])
			prime[++cnt]=i,phi[i]=i-1,mu[i]=-1;
		for(int j=1;j<=cnt&&i*prime[j]<=N;++j)
		{
			visit[i*prime[j]]=1;
			if(i%prime[j]==0)
			{
				phi[i*prime[j]]=phi[i]*prime[j];
				break;
			}
			phi[i*prime[j]]=phi[i]*phi[prime[j]];
			mu[i*prime[j]]=-mu[i];
		}
	}
	for(int i=1;i<=N;++i)
		phi[i]+=phi[i-1],mu[i]+=mu[i-1];
	
}

unordered_map<int,ll> mphi;
unordered_map<int,int> mmu;

inline ll calphi(int n)
{
	if(n<=N)
		return phi[n];
	if(mphi[n])
		return mphi[n];
	int l=2,r;
	ll ans=1ll*(1+n)*n/2; 
	while(l<=n)
	{
		r=n/(n/l);
		ans-=1ll*(r-l+1)*calphi(n/l);
		l=r+1;
	}
	return mphi[n]=ans;
}

inline int calmu(int n)
{
	if(n<=N)
		return mu[n];
	if(mmu[n])
		return mmu[n];
	int l=2,r;
	ll ans=1;
	while(l<=n)
	{
		r=n/(n/l);
		ans-=1ll*(r-l+1)*calmu(n/l);
		l=r+1;
	} 
	return mmu[n]=ans;
}

int main()
{   
    init();
    T=read();
    while(T--)
    {
    	n=read();
    	printf("%lld %d\n",calphi(n),calmu(n));
    }
	return 0;
}