莫比乌斯反演

有错请纠正，谢谢。

莫比乌斯函数

这个比较简单，前置知识 $积性函数$。

积型函数是满足 $\forall a,b$，如果有 $(a,b)=1$，都有 $f(ab)=f(a)\times f(b)$。

完全积型函数是 $\forall a,b$ 都有 $f(ab)=f(a)\times f(b)$。

这里，我们首先对一个数 $x$ 做他的标准质因数分解，记作：$x=\prod _{i=1}^k{a}_i$。

莫比乌斯函数为：

$$\mu (x)=\begin{array}{l}\{\begin{array}{c}1x=1\\ (-1{)}^{k}max(a_i)=1\\ 0otherwide\end{array}\end{array}$$

莫比乌斯函数的一些性质：

①对于 $\forall n\in N^{+}$，都有 $\sum _{d|n}\mu (d)=[n=1]$

②对于 $\forall n\in N^{+}$，都有 $\sum _{d|n}\frac{\mu (d)}{d}=\frac{\phi (n)}{n}$

③对于 $\forall n\in P$，都有 $\mu (n)=-1$

#include<bits/stdc++.h>
using namespace std;
const int N=1e7+1000;
int mu[N],pri[N],tot;
bool npr[N];
void getmu(int n){
    memset(npr,0,sizeof npr);
    tot=0,mu[1]=1;
    for(int i=2;i<=n;++i){
        if(!npr[i])pri[++tot]=i,mu[i]=-1;
        for(int j=1;j<=tot&&i*pri[j]<=n;++j){
            npr[pri[j]*i]=1;
            if(i%pri[j])mu[i*pri[j]]=-mu[i];
            else break;
        }
    }
}
int m;
int main(){
	getmu(N); 
	scanf("%d",&m);
	for(int i=1;i<=m;i++){
		printf("%d\n",mu[i]);
	}
	return 0;
}

简短的线性筛筛莫比乌斯函数。

莫比乌斯反演

反演的作用是找出一个容易求解的函数 $F(x)$，通过这个函数来求解其约数或倍数 $d$ 的函数 $f(d)$。

反演两种形式：

① $F(n)=\sum _{d|n}f(d)\to f(n)=\sum _{d|n}\mu (\frac{n}{d})F(d)$

② $F(n)=\sum _{n|d}f(d)\to f(n)=\sum _{n|d}\mu (\frac{d}{n})F(d)$

例题 $1$

ZAP-Queries

我们在说这道题目之前需要补充一个非常有名的恒等式。

$[\gcd (i,j)=1]=\sum _{d|\gcd (i,j)}\mu (d)$

证明略。

我们来看回这道题目：

其实就是求出 $\sum _{i=1}^a\sum _{j=1}^b[\gcd (i,j)=d]$

我们可以先操作一步，将 $\gcd$ 中的 $d$ 提取出来，然后就可以化成这样一个式子：（不妨设 $a\le b$）

$\sum _{i=1}^{\lfloor \frac{a}{d}\rfloor }\sum _{j=1}^{\lfloor \frac{b}{d}\rfloor }[\gcd (i,j)=1]$

然后，使用我们刚刚的式子，就可以得到：

$\sum _{i=1}^{\lfloor \frac{a}{d}\rfloor }\sum _{j=1}^{\lfloor \frac{b}{d}\rfloor }\sum _{k|\gcd (i,j)}\mu (k)$

我们可以将 $i\to \lfloor \frac{i}{k}\rfloor$，$j\to \lfloor \frac{j}{k}\rfloor$，这样就可以避免去枚举 $k|\gcd (i,j)$ 导致不必要的时间复杂度。

$\sum _{k=1}^a\sum _{i=1}^{\lfloor \frac{a}{kd}\rfloor }\sum _{j=1}^{\lfloor \frac{b}{kd}\rfloor }\mu (k)$

我们发现 此时 $\mu (k)$ 已经不受 $i,j$ 的限制了。所以，我们可以直接将这个玩意儿提到 ${\sum }_{i=1}^{\lfloor \frac{a}{kd}\rfloor }{\sum }_{j=1}^{\lfloor \frac{b}{kd}\rfloor }$ 之外，就可以得到：

$ans=\sum _k^a\mu (k)\lfloor \frac{a}{kd}\rfloor \lfloor \frac{b}{kd}\rfloor$

我们发现 $\sum _k^a\mu (k)$ 这个玩意儿，是可以提前 $O(n)$ 使用前缀和预处理的。

于是，代码如下：

#include<bits/stdc++.h>
using namespace std;
const int N=1e7+1000,M=1e6;
int prime[N],mu[N],cnt;
bool flag[N];
#define ll long long
ll tot[N],a,b,d;
void get_mu(){
	mu[1]=1; 
	for(int i=2;i<=M;i++){
		if(!flag[i])prime[++cnt]=i,mu[i]=-1;
		for(int j=1;j<=cnt&&prime[j]*i<=M;j++){
			flag[i*prime[j]]=true;
			if(i%prime[j]==0)break;
			mu[i*prime[j]]=-mu[i];
		}
	}
	for(int i=1;i<=M;i++){
		tot[i]=tot[i-1]+mu[i];
	}
}
ll solve(ll a,ll b){
	if(a>b)swap(a,b);
	ll ans=0;
	for(int l=1,r;l<=a;l=r+1){
		r=min(a/(a/l),b/(b/l));
		ans+=(tot[r]-tot[l-1])*(a/l)*(b/l);
	}
	return ans;
}
int main(){
	int t;
get_mu();
	scanf("%d",&t);
	while(t--){
		scanf("%lld %lld %lld",&a,&b,&d);
		printf("%lld\n",solve(a/d,b/d));
	}
	return 0;
}

例题 $2$

YY的GCD

我们首先构建最基本函数 $f(x)=\sum _{x=1}^n\sum _{y=1}^m[(x,y)\in P]$

我们可以开始枚举一下 $\gcd (x,y)$，不妨设这个东西是 $k$。

则式子变为 $\sum _{k\in P}\sum _{x=1}^n\sum _{y=1}^m[(x,y)=k]$

我们对这个式子同时除以 $k$，得到：

$ans=\sum _{k\in P}\sum _{x=1}^{\lfloor \frac{n}{k}\rfloor }\sum _{y=1}^{\lfloor \frac{m}{k}\rfloor }[(x,y)=1]$

我们发现这个式子可以化为 $\sum _{k\in P}\sum _{x=1}^{\lfloor \frac{n}{k}\rfloor }\sum _{y=1}^{\lfloor \frac{m}{k}\rfloor }\sum _{d|\gcd (x,y)}\mu (d)$

我们现将 $d$ 提出来，由于要想让 $\mu (d)$ 有贡献，我们必须让其满足 $d|x$ 并且 $d|y$， 然后我们就可以喜闻乐见的发现，中间的两个 $\sum$ 都消失啦，分别变成了 $\lfloor \frac{n}{kd}\rfloor$ 和 $\lfloor \frac{m}{kd}\rfloor$！

我们就可以得到下面这个还算整洁的式子：（不妨设 $n\le m$）$\displaystyle \sum_{k\in P}^{n} \displaystyle \sum_{d}^{\lfloor\frac n k\rfloor}\mu(d)\lfloor \frac n {kd} \rfloor\lfloor \frac m {kd} \rfloor $

我们是可以在 $O(n)$ 时间复杂度内筛出 $\mu (d)$的，同时也可以筛出质数。

$\lfloor \frac{n}{kd}\rfloor \lfloor \frac{m}{kd}\rfloor$ 可以 $O(1)$ 处理。

我们接下来只需要处理一下 $\sum _d^{\lfloor \frac{n}{k}\rfloor }\mu (d)$ 这一块就可以了。

我们在这里使用 数论分块（反正不是分块,其实这个可以点）进行 $O(\sqrt{n})$ 的求解。

于是,我们就可以快乐地解出答案啦！

#include<bits/stdc++.h>
using namespace std;
#define ll long long
const int N=1e7+1000,M=1e7;
int t;
bool isprime[N];
int mu[N],prime[N],cnt,f[N];
ll tot[N],n,m;
void get_mu(){
	mu[1]=1;
	for(int i=2;i<=M;i++){
		if(!isprime[i])prime[++cnt]=i,mu[i]=-1;
		for(int j=1;j<=cnt&&prime[j]*i<=M;j++){
			isprime[prime[j]*i]=true;
			if(i%prime[j]==0)break;
			mu[i*prime[j]]=-mu[i];
		}
	}
	for(int i=1;i<=cnt;i++){
		for(int j=1;j*prime[i]<=M;j++){
			f[j*prime[i]]+=mu[j];
		}
	}
	for(int i=1;i<=M;i++)tot[i]=tot[i-1]+f[i];
}
ll solve(ll x,ll y){
	ll ans=0;
	if(x>y)swap(x,y);
	for(ll l=1,r;l<=x;l=r+1){
		r=min(x/(x/l),y/(y/l));
		ans+=(tot[r]-tot[l-1])*(x/l)*(y/l);
	}
	return ans;
}
int main(){
	get_mu();
	scanf("%d",&t);
	while(t--){
		scanf("%lld %lld",&n,&m);
		printf("%lld\n",solve(n,m));
	}
	return 0;
}

例题 $3$

这道题目让我们求出 $\sum _{i=1}^n\sum _{j=i+1}^n\gcd (i,j)$。

我们不会求 $\sum \gcd (i,j)$，只会求 $\sum [gcd(i,j)=1]$

令 $\gcd (i,j)=d$

所以，我们将 $d$ 提取出来，然后得到：

$\sum _{d=1}^{n}d\times \sum _{i=1}^n\sum _{j=i+1}^n[\gcd (i,j)==1]$

我们又可以欣喜的化简出来啦：

$\sum _{d=1}^{n}d\times \sum _{i=1}^n\sum _{j=i+1}^n\sum _{d|\gcd (i,j)}\mu (d)$

然后还是像上面一样对这个式子进行化简，但是，我们还是要重新减去一些：

$\sum _{d=1}^{n}d\times \sum _{k=1}^{\lfloor \frac{n}{d}\rfloor }\mu (k)\lfloor \frac{n}{d}\rfloor \lfloor \frac{n}{d}\rfloor$

我们还是可以预处理 $\mu (k)$ 的前缀和，然后用数论分块 $O(\sqrt{\frac{n}{d}})$ 的时间复杂度处理每一次关于 $d$ 的查询。

于是代码可以如下：

#include<bits/stdc++.h>
using namespace std;
const int N=5e6+1000,M=5e6;
#define ll long long
ll tot[N],ans;
bool flag[N];
int mu[N],prime[N],cnt;
void get_mu(){
	mu[1]=1;
	for(int i=2;i<=M;i++){
		if(!flag[i])mu[i]=-1,prime[++cnt]=i;
		for(int j=1;j<=cnt&&prime[j]*i<=M;j++){
			flag[prime[j]*i]=true;
			if(i%prime[j]==0)break;
			mu[i*prime[j]]=-mu[i];
		}
	}
	for(int i=1;i<=M;i++)tot[i]=tot[i-1]+mu[i];
	return;
}
ll solve(ll a,ll b){
	ll ans=0;
	a/=b;
	for(int l=1,r;l<=a;l=r+1){
		r=min(a/(a/l),a);
		ans+=(tot[r]-tot[l-1])*(a/l)*(a/l);
	}
	return ans;
}
int main(){
	get_mu();
	ll n;
	cin>>n;
	for(int i=1;i<=n;i++){
		ans+=(i*solve(n,i));
	}
	ans-=(n*(n+1)/2);
	ans/=2;
	cout<<ans<<'\n';
	return 0;
}

例题 $4$

P2522-Problem b

我们可以根据前面的经验，可以知道：

$\sum _{i=1}^a\sum _{j=1}^b[\gcd (i,j)=k]$ 可以化简为：

$ans=\sum _k^a\mu (k)\lfloor \frac{a}{kd}\rfloor \lfloor \frac{b}{kd}\rfloor$

我们接着思考如何计算：

我们发现，可以使用容斥原理来计算这个问题的答案，所以我们可以写出这个简单易懂的代码。

#include<bits/stdc++.h>
using namespace std;
#define ll long long
const int N=1e6+1000;
const int M=1e6;
int t;
ll a,b,c,d,k;
ll tot[N];
int mu[N],prime[N],cnt;
bool flag[N];
void get_mu(){
	mu[1]=1;
	for(int i=2;i<=M;i++){
		if(!flag[i])prime[++cnt]=i,mu[i]=-1;
		for(int j=1;j<=cnt&&prime[j]*i<=M;j++){
			flag[i*prime[j]]=true;
			if(i%prime[j]==0)break;
			mu[i*prime[j]]=-mu[i]; 
		}
	}
	for(int i=1;i<=M;i++)tot[i]=tot[i-1]+mu[i];
	return; 
}
ll solve(ll a,ll b){
	ll ans=0;
	a/=k;b/=k;
	if(a>b)swap(a,b);
	for(ll l=1,r=0;l<=a;l=r+1){
		r=min(a/(a/l),b/(b/l));
		ans+=(tot[r]-tot[l-1])*(a/l)*(b/l);
	}
	return ans;
}
int main(){
	get_mu();
	scanf("%d",&t);
	while(t--){
		scanf("%lld %lld %lld %lld %lld",&a,&b,&c,&d,&k);
		printf("%lld\n",solve(b,d)-solve(a-1,d)-solve(b,c-1)+solve(a-1,c-1));
	}
	return 0;
}

这就是基础的莫比乌斯反演了。

希望大家可以继续学习。