莫比乌斯反演初步

1 简介

莫比乌斯反演，俗称懵逼钨丝繁衍，顾名思义就是一看就叫人懵逼的算法。我在颓废了一天的莫反之后，成功地被莫反弄懵逼了。它的根本思想就是容斥原理，而莫比乌斯函数则用于辅助进行容斥的计算。

莫比乌斯函数的定义像一个容斥符号的定义：
对于$n=p_1{p}_2{p}_3\dots p_k$，有$\mu (n)=(-1{)}^k$，否则$\mu (n)=0$

---

如果对于一个函数$f(x)$，若有另一个函数
$$g(n)=\sum _{d|n}f(d)$$
那么就有
$$f(n)=\sum _{d|n}\mu (d)g(\frac{n}{d})$$
另一种反演形式：
$$g(n)=\sum _{n|d}f(d)\Rightarrow f(n)=\sum _{n|d}\mu (\frac{d}{n})g(d)$$

这个g函数的设置看似很无厘头，但是在某些时候函数g会比函数f好算得多，这可以加速计算。

2 相关证明(卷积法)

引自：知乎

2.1

定义f,g为两个函数。则其卷积运算为：
$$(f\ast g)(n)=\sum _{ij=n}f(i)g(j)$$

2.2

我们定义卷积意义下的单位元$\iota$，满足：
$$\iota \ast f=f$$
即是：
$$(\iota \ast f)(n)=\sum _{ij=n}\iota (i)f(i)=f(n)$$
由卷积的运算，易知：
$$\iota =\{\begin{array}{r}1,n=1\\ 0,n̸=1\end{array}$$

2.3

我们定义乘法单位元为在普通乘法$(fg)(n)=f(n)g(n)$意义下的单位元，记作$u$。即：
$${\forall }_{i\in I}u(i)=1$$

2.4

我们将$u$在卷积意义下的逆元称为莫比乌斯函数。即它们满足：
$$u\ast \mu =\iota$$
对于$\mu$满足性质${\sum }_{d|n}\mu (d)=0,n>1$

证明如下：
$$\begin{array}{rl}\sum _{d|n}\mu (d)& =\mu (1)+\mu (p_1)+\dots +\mu (p_k)+\mu (p_1{p}_2)+\mu (p_1{p}_2\dots p_k)\\ & =\left(\begin{array}{r}k\\ 0\end{array}\right)+\left(\begin{array}{r}k\\ 1\end{array}\right)(-1)+\left(\begin{array}{r}k\\ 2\end{array}\right)(-1{)}^2+\dots +\left(\begin{array}{r}k\\ k\end{array}\right)(-1{)}^k\\ & =(1-1{)}^k=0\end{array}$$

2.5

那么莫比乌斯反演用数学语言描述就是：

当且仅当
$$f(n)=\sum _{d|n}g(d)$$
满足
$$g(n)=\sum _{d|n}\mu (\frac{n}{d})f(d)$$

换而言之：$f=g\ast u\iff g=f\ast \mu$

将左边的式子两边同乘$\mu$即可证明之

3 性质

$n{\sum }_{d|n}\frac{\mu (d)}{d}=\varphi (n)$

证明

对于$\varphi (x)=x(1-\frac{1}{p_1})(1-\frac{1}{p_2})\dots (1-\frac{1}{p_k})$，我们把除x之外的所有数都乘起来，得
$$\varphi (x)=x(1-\sum _{i=1}^k\frac{1}{p_i}+\sum _{i,j=1,i̸=j}^k\frac{1}{p_i{p}_j}\dots )$$
而我们可以发现其式子中的$p_i,p_i{p}_j,p_i{p}_j{p}_r\dots$就是x的所有约数，而其相应的符号则与上面的莫比乌斯函数之定义相符，也就是说$\varphi (x)={\sum }_{d|x}\frac{x}{d}\mu (d)={\sum }_{d|x}d\mu (\frac{x}{d})$

4 线性筛求莫比乌斯函数

void init()
{
	miu[1]=1;
	for(int i=2;i<=50000;i++)
	{
		if(!is[i]){pri[++tot]=i;miu[i]=-1;}
		for(int j=1;j<=tot;j++)
		{
			int k=i*pri[j];
			if(k>50000) break;
			is[k]=1;
			if(i%pri[j]==0){miu[k]=0;break;}
			else miu[k]=-miu[i];
		}
	}
}

实际应用时，还可以做底数优化，对其进行前缀和处理，可将复杂度优化至$O(\sqrt{n})$。详见例题。

5 例题

[HAOI2011] Problem b(bzoj2301)

题意：给定五个整数a,b,c,d,e,求满足$gcd(x,y)=e,x\in [a,b],y\in [c,d]$的数对(x,y)对数。

题解：对于$a=c=1$的特殊情况，就相当于求满足$gcd(x,y)=1,x\in [1,b/e],y\in [1,d/e]$的数对对数。

我们不妨设$f(i)$表示条件为$gcd(x,y)=i$时的答案。则f(1)即为所求。构造$g(i)$表示满足$gcd(x,y)=k\ast i,k\in Z^{\ast }$的数对对数。那么可以知道$g(i)=\frac{b}{i}\ast \frac{d}{i}$，就可以愉快地求f(i)的值了。

然而时间复杂度是$O(n)$，TLE妥妥的。考虑怎么优化，注意到在某一段区间内的$\frac{n}{i}$取值相等（因为向下取整了嘛），那么就一起计算。然后脑补一下，你就会发现$n/(n/i)$就是取值相等的段末位置。时间复杂度$O(\sqrt{n})$。

最后再用容斥乱搞一通即可。

代码：

#include <iostream>
#include <cstdio>
using namespace std;
typedef long long ll;
const int maxn=50010;
int z,a,b,c,d,e,tot,pri[maxn],is[maxn],miu[maxn],sum[maxn];
ll ans;
inline int min(int x,int y){return x<y?x:y;}
void init()
{
    miu[1]=1;
    for(int i=2;i<=50000;i++)
    {
        if(!is[i]){pri[++tot]=i;miu[i]=-1;}
        for(int j=1;j<=tot;j++)
        {
            int k=i*pri[j];
            if(k>50000) break;
            is[k]=1;
            if(i%pri[j]==0){miu[k]=0;break;}
            else miu[k]=-miu[i];
        }
    }
    sum[1]=miu[1];
    for(int i=2;i<=50000;i++)
      sum[i]=sum[i-1]+miu[i];
}
ll check(int x,int y)
{
    ll res=0;
    int t=min(x,y);
    for(int i=1,j;i<=t;i=j+1)
    {
        j=min(x/(x/i),y/(y/i));
        res+=(ll)(sum[j]-sum[i-1])*(x/i)*(y/i);
    }
    return res;
}
int main()
{
    #ifndef ONLINE_JUDGE
    freopen("in.txt","r",stdin);
    #endif
    init();
    scanf("%d",&z);
    while(z--)
    {
        scanf("%d%d%d%d%d",&a,&b,&c,&d,&e);
        ans=check(b/e,d/e)-check((a-1)/e,d/e)-check(b/e,(c-1)/e)+check((a-1)/e,(c-1)/e);
        printf("%lld\n",ans);
    }
    return 0;
}