莫比乌斯反演总结

PoPoQQQ大神的PPT：
https://wenku.baidu.com/view/fbec9c63ba1aa8114431d9ac.html?from=search

其实莫比乌斯反演就这个东西：

$~$
如果有：

$$F(d)=\sum_{i|d}f(i)$$
那么有：

$$f(d)=\sum_{i|d}\mu(i)F(\frac{d}{i})$$
$~$
另一种形式是如果
$$F(d)=\sum_{d|i}f(i)$$
那么
$$f(d)=\sum_{d|i}\mu(\frac{i}{d})F(i)$$

$~$
其中$\mu$是莫比乌斯函数，定义域为非负整数，定义如下：
（１）$\mu(1)=1$
（２）若ｄ为若干个互异素数之积，即$d=p_1p_2p_{3}...p_k$，那么有$\mu(d)=(-1)^k$
（３）其他情况下$\mu(d)=0$

$\mu$是积性函数，即对于任意正整数x,y，如果有gcd(x,y)=1，那么有$\mu(x)\mu(y)=\mu(xy)$
所以我们可以用线性筛求出$\mu$：

mu[1]=1;
for(int i=2;i<=x;i++){
    if(!ok[i]){
        prime[++prime[0]]=i;
        mu[i]=-1;
    }
    for(int j=1;j<=prime[0]&&i*prime[j]<=x;j++){
        ok[i*prime[j]]=true;
        if(i%prime[j])mu[i*prime[j]]=-mu[i];
        else{
            mu[i*prime[j]]=0;
            break;
        }
    }
}

所以我们有了它能做什么？
如果有一个不是很好求的函数f，那么我们可能可以通过反演求出它的值．

首先一道最简单的例题：Bzoj1101 Zap
这是个权限题，看不了没关系，题目大意就是对于给定的整数a,b和d，有多少正整数对x,y，满足$x\leq a,y\leq b$，并且gcd(x,y)=d。
即求：

$$\sum_{i=1}^{a}\sum_{j=1}^{b}[gcd(i,j)==d]$$
我们可以把d除掉，令 $n=\lfloor\frac{a}{d}\rfloor,m=\lfloor\frac{b}{d}\rfloor$，那么答案就是：
$$\sum_{i=1}^{n}\sum_{j=1}^{m}[gcd(i,j)==1]$$
我们不妨令
$$f(d)= \sum_{i=1}^{n}\sum_{j=1}^{m}[gcd(i,j)==d]$$
$$F(d)= \sum_{i=1}^{n}\sum_{j=1}^{m}[d|gcd(i,j)]$$
然后我们会发现， $$F(d)=\sum_{d|i}f(i)$$
莫比乌斯反演得 $$f(d)=\sum_{d|i}\mu(\frac{i}{d})F(i)$$
而F(i)是很好求的，因为有 $$F(i)=\lfloor\frac{n}{i}\rfloor\lfloor\frac{m}{i}\rfloor$$ 所以我们可以很快通过F求出f.
所以我们要的答案f(1)就是等于：
$$f(1)=\sum_{i=1}^{min(n,m)}\mu(i)\lfloor\frac{n}{i}\rfloor\lfloor\frac{m}{i}\rfloor$$
现在我们可以Ｏ(n)出解，但是由于多组数据我们还要以优化．
考虑到 $\lfloor\frac{n}{i}\rfloor\lfloor\frac{m}{i}\rfloor$最多只有 $2(\sqrt n+\sqrt m)$个取值，所以我们按照这个的值分块计算，所以预处理一下 $\mu$的前缀和即可．
那么这个代码怎么写？

LL nxt,tot=0;
for(int i=1;i<=min(n,m);i=nxt+1){
    nxt=min(n/(n/i),m/(m/i));//计算当前ｉ对应的值域的上界
    tot+=(n/i)*(m/i)*(sum[nxt]-sum[i-1]);
    //sum是莫比乌斯函数的前缀和
}
return tot;

所以现在复杂度是O($\sqrt n$)，多组数据可以过．
$~$
不过问题来了，我们是怎么想到F这个函数对进行反演的？如果在题目简单的情况下，可以比较容易看出F，可如果题目难，我们怎么知道用哪个函数来反演？

我们可以先试着用容斥的方法做这道题：
$~$
范围内gcd为1的数对个数＝(范围内gcd是1的倍数的数对个数)－(范围内gcd是2的倍数的数对个数)－(范围内gcd是3的倍数的数对个数)－(范围内gcd是5的倍数的数对个数)+(范围内gcd是6的倍数的数对个数)……
因为(范围内gcd是4的倍数的数对个数)在第2项处已经被减掉了，所以不用再减一次．
而(范围内gcd是6的倍数的数对个数)在第2项和第3项处被减掉了2次，所以要加回来一次．

我们发现了什么？是不是这里有一个莫比乌斯函数？

$$\mu(1)=1,\mu(2)=-1,\mu(3)=-1,\mu(4)=0,\mu(5)=-1,\mu(6)=1$$
是不是很神奇？莫比乌斯函数就是容斥中每一项的系数！
其实根据莫比乌斯函数的定义和容斥的规则我们就可以发现这个性质．
$~$
所以这题我们可以根据容斥直接列式计算，上面的容斥就是这个式子：
$$ans=\sum_{i=1}^{min(n,m)}\mu(i)\lfloor\frac{n}{i}\rfloor\lfloor\frac{m}{i}\rfloor$$
同样，很多莫比乌斯反演的题目都可以根据容斥直接列式．
$~$

Bzoj2301 Problem B
这题比上一题多了一个下界，我们转化一下答案即可用同样的方法解决．
代码：

#include<cstdio>
#include<algorithm>

typedef long long LL;
const int maxn=50010;
int T,a,b,c,d,k,mu[maxn],prime[maxn],sum[maxn];
bool not_prime[maxn];

void Make(){
    not_prime[1]=mu[1]=1;
    for(int i=1;i<=50000;i++){
        if(!not_prime[i]){
            prime[++prime[0]]=i;
            mu[i]=-1;
        }
        for(int j=1;j<=prime[0]&&i*prime[j]<=50000;j++){
            not_prime[i*prime[j]]=true;
            if(i%prime[j]==0){
                mu[i*prime[j]]=0;
                break;
            }
            mu[i*prime[j]]=-mu[i];
        }
    }
    for(int i=1;i<=50000;i++)sum[i]=sum[i-1]+mu[i];
}
LL Work(LL n,LL m){
    n/=k;m/=k;
    if((!n)||(!m))return 0;
    if(n>m)std::swap(n,m);
    LL tot=0;
    for(int i=1,nxt;i<=n;i=nxt+1){
        nxt=std::min(n/(n/i),m/(m/i));
        tot+=(n/i)*(m/i)*(sum[nxt]-sum[i-1]);
    }
    return tot;
}

int main(){
    Make();
    scanf("%d",&T);
    while(T--){
        scanf("%d%d%d%d%d",&a,&b,&c,&d,&k);
        printf("%lld\n",Work(b,d)-Work(a-1,d)-Work(b,c-1)+Work(a-1,c-1));
    }
    return 0;
}

$~$
Bzoj2440 完全平方数
考虑二分答案．对于当前答案n，我们考虑如何求出它之前（包括它）有多少个数是合法的.用容斥列式，枚举完全平方数：

$$合法的数个数＝\sum_{i=1}^{n}\mu(i)\lfloor\frac{n}{i^2}\rfloor$$
其中 $\lfloor\frac{n}{i^2}\rfloor$是n以内是 $i^2$整数倍的数的个数．
由于 $i^2$大于n时 $\lfloor\frac{n}{i^2}\rfloor$为0,所以我们只需要枚举i到 $\sqrt n$即可．
复杂度O( $\sqrt n\log_2n$)
代码：

#include<cstdio>
#include<algorithm>
using namespace std;

typedef long long LL;
const int maxn=100010,maxl=100000;
int T,n,mu[maxn],prime[maxn];
bool ok[maxn];

void Make(){
    mu[1]=1;
    for(int i=2;i<=maxl;i++){
        if(!ok[i]){
            prime[++prime[0]]=i;
            mu[i]=-1;
        }
        for(int j=1;j<=prime[0]&&i*prime[j]<=maxl;j++){
            ok[i*prime[j]]=true;
            if(i%prime[j])mu[i*prime[j]]=-mu[i];
            else{
                mu[i*prime[j]]=0;
                break;
            }
        }
    }
}
LL check(LL ans){
    LL tot=0;
    for(LL i=1;i*i<=ans;i++){
        tot+=ans/(i*i)*mu[i];
    }
    return tot;
}
LL Binary(LL l,LL r){
    LL mid,ans;
    while(l<=r){
        mid=(l+r)>>1;
        if(check(mid)<n)l=mid+1;
        else ans=mid,r=mid-1;
    }
    return ans;
}

int main(){
    Make();
    scanf("%d",&T);
    while(T--){
        scanf("%d",&n);
        printf("%lld\n",Binary(n,n<<1));
    }
    return 0;
}

$~$
Bzoj3529 数表
大意：
F(i)为i的约数和，求：

$$\sum_{i=1}^n\sum_{j=1}^mF(gcd(i,j))\ \ mod\ 2^{31}$$
要求计算进入结果的$F(gcd(i,j))\leq a$

我们先不考虑a的限制．
令g(i)为$1\leq x\leq n,1\leq y\leq m$且gcd(x,y)=i的数对(x,y)的个数．
前面我们知道了$g(i)=\sum_{i|d}\mu(\frac{d}{i})\lfloor\frac{n}{d}\rfloor\lfloor\frac{m}{d}\rfloor$,
则：

$$ans=\sum_{i=1}^{min(n,m)}F(i)g(i)=\sum_{i=1}^{min(n,m)}F(i)\sum_{i|d}\mu(\frac{d}{i})\lfloor\frac{n}{d}\rfloor\lfloor\frac{m}{d}\rfloor$$
$$=\sum_{d=1}^{min(n,m)}\lfloor\frac{n}{d}\rfloor\lfloor\frac{m}{d}\rfloor\sum_{i|d}F(i)\mu(\frac{d}{i})$$
我们对于每个d预处理出 $\sum_{i|d}F(i)\mu(\frac{d}{i})$及其前缀和，这个可以O( $n\log_2 n$)做到，然后单组询问O( $\sqrt n$)，可以过．
$~$
再考虑加了a的限制怎么做．
我们知道对当前答案有贡献的都是满足$F(i)\leq a$的部分．
所以不妨离线所有询问，按照a的增序回答询问，用树状数组维护 $\sum_{i|d}F(i)\mu(\frac{d}{i})$的前缀和，询问的a变大就新插入一些对答案有贡献的值．总复杂度O( $n\log_2n+q\sqrt n\log_2n$)．
代码：

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;

inline int read(){
    int x=0,f=1;char ch=getchar();
    for(;ch<'0'||ch>'9';ch=getchar())if(ch=='-')f=-1;
    for(;ch>='0'&&ch<='9';ch=getchar())x=x*10+ch-'0';
    return x*f;
}

typedef long long LL;
const int maxn=100010,maxl=100000;
const LL mod=1ll<<31;
struct array{
    #define lowbit(x) (x&-x)
    int n;
    LL a[maxn];
    array(){memset(a,0,sizeof a);n=maxl;}
    void add(int x,LL k){
        while(x<=n){
            a[x]+=k;
            x+=lowbit(x);
        }
    }
    LL sum(int x){
        LL tot=0;
        while(x){
            tot+=a[x];
            x-=lowbit(x);
        }
        return tot;
    }
}a;
struct Q{
    LL n,m,a,id;
    bool operator<(Q b)const{
        return a<b.a;
    }
}q[maxn];
int T,mu[maxn],prime[maxn];
LL ans[maxn];
pair<LL,int>f[maxn];
bool ok[maxn];

void Make(){
    mu[1]=1;
    for(int i=2;i<=maxl;i++){
        if(!ok[i]){
            prime[++prime[0]]=i;
            mu[i]=-1;
        }
        for(int j=1;j<=prime[0]&&i*prime[j]<=maxl;j++){
            ok[i*prime[j]]=true;
            if(i%prime[j])mu[i*prime[j]]=-mu[i];
            else{
                mu[i*prime[j]]=0;
                break;
            }
        }
    }
    for(int i=1;i<=maxl;i++){
        for(int j=i;j<=maxl;j+=i){
            f[j].first+=i;
        }
    }
    for(int i=1;i<=maxl;i++)f[i].second=i;
}
LL Query(LL n,LL m){
    if(n>m)swap(n,m);
    LL tot=0;
    for(int i=1,nxt;i<=n;i=nxt+1){
        nxt=min(n/(n/i),m/(m/i));
        tot+=(n/i)*(m/i)*(a.sum(nxt)-a.sum(i-1))%mod;
        tot%=mod;tot=(tot+mod)%mod;
    }
    return (tot+mod)%mod;
}

int main(){
    Make();T=read();
    for(int i=1;i<=T;i++){
        q[i].n=read();q[i].m=read();
        q[i].a=read();q[i].id=i;
    }
    sort(f+1,f+maxl+1);sort(q+1,q+T+1);
    for(int t=1,i=1;t<=T;t++){
        for(;i<=maxl&&f[i].first<=q[t].a;i++){
            for(int j=f[i].second;j<=maxl;j+=f[i].second){
                a.add(j,mu[j/f[i].second]*f[i].first);
            }
        }
        ans[q[t].id]=Query(q[t].n,q[t].m);
    }
    for(int i=1;i<=T;i++)printf("%lld\n",ans[i]);
    return 0;
}

$~$
Bzoj2154 Crash的数字表格
大意：给定n,m(n,m$\leq 10^7$)，求:

$$\sum_{i=1}^{n}\sum_{j=1}^{m}lcm(i,j)$$
变形：
$$ans=\sum_{i=1}^{n}\sum_{j=1}^{m}\frac{ij}{gcd(i,j)}$$
令 $$F(x,y)=\sum_{i=1}^{x}\sum_{j=1}^{y}ij[gcd(i,j)==1]$$
枚举d=gcd(i,j)：
$$ans=\sum_{d=1}^{min(n,m)}\frac{d^2F(\lfloor\frac{n}{d}\rfloor\lfloor\frac{m}{d}\rfloor)}{d}=\sum_{d=1}^{min(n,m)}dF(\lfloor\frac{n}{d}\rfloor\lfloor\frac{m}{d}\rfloor)$$
根据容斥可以列出F的表达式：
$$F(x,y)=\sum_{i=1}^{min(x,y)}\mu(i)\sum_{p=1}^{\lfloor\frac{x}{i}\rfloor}\sum_{q=1}^{\lfloor\frac{y}{i}\rfloor}pi*qi$$
$$=\sum_{i=1}^{min(x,y)}i^2\mu(i)\frac{\lfloor\frac{x}{i}\rfloor(\lfloor\frac{x}{i}\rfloor+1)}{2}\frac{\lfloor\frac{y}{i}\rfloor(\lfloor\frac{y}{i}\rfloor+1)}{2}$$
预处理出 $\mu(i)*i^2$的前缀和可以O( $\sqrt n$)求出F.
所以可以O( $\sqrt n\sqrt n$)=O(n)求出答案．
代码：

#include<cstdio>
#include<algorithm>
using namespace std;

typedef long long LL;
const int maxn=10000010,mod=20101009;
LL n,m,fac[maxn];
int mu[maxn],prime[maxn];
bool ok[maxn];

void Init(int x){
    mu[1]=1;
    for(int i=2;i<=x;i++){
        if(!ok[i]){
            prime[++prime[0]]=i;
            mu[i]=-1;
        }
        for(int j=1;j<=prime[0]&&i*prime[j]<=x;j++){
            ok[i*prime[j]]=true;
            if(i%prime[j])mu[i*prime[j]]=-mu[i];
            else{
                mu[i*prime[j]]=0;
                break;
            }
        }
    }
    for(LL i=1;i<=x;i++)fac[i]=((fac[i-1]+mu[i]*i*i%mod)%mod+mod)%mod;
}
LL F(LL x,LL y){
    if(x>y)swap(x,y);
    if(!x)return 0;
    LL nxt,tot=0;
    for(LL i=1;i<=x;i=nxt+1){
        nxt=min(x/(x/i),y/(y/i));
        tot=(tot+(x/i)*(x/i+1)/2%mod*((y/i)*(y/i+1)/2%mod)%mod*(((fac[nxt]-fac[i-1])%mod+mod)%mod)%mod)%mod;
    }
    return tot;
}
LL Calc(LL x,LL y){
    LL nxt,tot=0;
    for(LL i=1;i<=x;i=nxt+1){
        nxt=min(x/(x/i),y/(y/i));
        (tot+=(nxt+i)*(nxt-i+1)/2%mod*F(x/i,y/i)%mod)%=mod;
    }
    return tot;
}

int main(){
    scanf("%lld%lld",&n,&m);
    if(n>m)swap(n,m);
    if(!n)return printf("0\n"),0;
    Init(n);
    printf("%lld\n",Calc(n,m));
    return 0;
}

$~$
Bzoj2693 jzptab
上一题的多组数据版本，还要继续优化．
记$sum(x,y)=\frac{x(x+1)}{2}\frac{y(y+1)}{2}$

$$ans=\sum_{d=1}^{min(n,m)}d\sum_{i=1}^{min(n,m)}i^2\mu(i)sum(\lfloor\frac{n}{di}\rfloor,\lfloor\frac{m}{di}\rfloor)$$
$$=\sum_{D=1}^{min(n,m)}sum(\lfloor\frac{n}{D}\rfloor,\lfloor\frac{m}{D}\rfloor)\sum_{i|D}\frac{D}{i}\mu(i)i^2$$
$$=\sum_{D=1}^{min(n,m)}sum(\lfloor\frac{n}{D}\rfloor,\lfloor\frac{m}{D}\rfloor)D\sum_{i|D}\mu(i)i$$
现在我们只要能O(n)之内求出 $\sum_{i|D}\mu(i)i$就可以O( $\sqrt n$)完成一组询问．
令 $f(i)=\mu(i)i$，若x,y互质，那么
$$f(x)f(y)=\mu(x)\mu(y)xy=\mu(xy)xy=f(xy)$$
所以f为积性函数．又积性函数的约数和为积性函数，
所以 $\sum_{i|D}\mu(i)i$为积性函数，所以我们可以通过线性筛求出它的值．
此题到此解决，复杂度为O( $n+q\sqrt n$)．
代码：

#include<cstdio>
#include<algorithm>
using namespace std;

typedef long long LL;
const int maxn=10000010,mod=100000009;
LL n,m,f[maxn],g[maxn],prime[maxn];
int T;
bool ok[maxn];

void Init(int x){
    f[1]=1;
    for(LL i=2;i<=x;i++){
        if(!ok[i]){
            prime[++prime[0]]=i;
            f[i]=1-i+mod;
        }
        for(int j=1;j<=prime[0]&&i*prime[j]<=x;j++){
            ok[i*prime[j]]=true;
            if(i%prime[j])f[i*prime[j]]=(f[i]*(1-prime[j])%mod)+mod;
            else{
                f[i*prime[j]]=f[i];
                break;
            }
        }
    }
    for(LL i=1;i<=x;i++)g[i]=(g[i-1]+i*f[i]%mod)%mod;
}
LL Sum(LL x,LL y){
    return (x*(x+1)/2%mod)*(y*(y+1)/2%mod)%mod;
}
LL Calc(LL x,LL y){
    LL nxt,tot=0;
    for(LL i=1;i<=x;i=nxt+1){
        nxt=min(x/(x/i),y/(y/i));
        (tot+=Sum(x/i,y/i)*((((g[nxt]-g[i-1])%mod)+mod)%mod)%mod)%=mod;
    }
    return tot;
}

int main(){
    Init(10000000);
    scanf("%d",&T);
    while(T--){
        scanf("%lld%lld",&n,&m);
        if(n>m)swap(n,m);
        if(!n){
            printf("0\n");
            continue;
        }
        printf("%lld\n",Calc(n,m));
    }
    return 0;
}

$~$
Spoj LCM Sum
求：$\sum_{i=1}^{n}lcm(i,n)\ \ \ \ n\leq10^7$，多组询问．
$~$
这道题根上面两题看起来有点像，但是解法不同．我们先化简式子：

$$ans=\sum_{i=1}^{n}lcm(i,n)=\sum_{i=1}^{n}\frac{i\times n}{gcd(i,n)}=n\sum_{i=1}^{n}\frac{i}{gcd(i,n)}$$
枚举d=gcd(i,n)

$$ans=n\sum_{d|n}\sum_{d|i}i/d[gcd(i/d,n/d)==1]$$
我们考虑怎么求出里面那个 $\sum$的值．
里面的那部分其实就是要求1~x内与x互质的数之和．
考虑反演，用容斥枚举gcd列式：
$$\sum_{d|x}\mu(d)(d+2d+3d+...+x)=\sum_{d|x}\mu(d)d\frac{(1+\frac{x}{d})\frac{x}{d}}{2}=\sum_{d|x}\mu(d)(\frac{x}{2}+\frac{x^2}{2d})$$
$$=\frac{x}{2}\sum_{d|x}\mu(d)+\frac{x^2}{2}\sum_{d|x}\frac{\mu(d)}{d}$$
当x=1时整个式子等于1
当x>1时第一项为0,我们考虑第二项：
其实第二项中的 $\sum_{d|x}\frac{\mu(d)}{d}＝\frac{\phi(x)}{x}$
这个结论要记一下，证明如下：
$$因为x=\sum_{d|x}\phi(d)\ \ \ \ \ （欧拉函数性质）\\莫比乌斯反演得：\phi(x)=\sum_{d|x}\mu(d)\frac{x}{d}$$
所以两边同时除以x就得到 $\sum_{d|x}\frac{\mu(d)}{d}＝\frac{\phi(x)}{x}$
$~$
综上，当x>1时，1~x中与x互质的数的个数为$\frac{x\phi(x)}{2}$
所以，
$$ans=n\sum_{d|n}\frac{\frac{n}{d}\phi(\frac{n}{d})}{2}$$
由于 $\frac{n}{d}=1$时 $\sum$里面的那一部分的值应该为1，但是我们直接算出来的值是 $\frac{1}{2}$向下取整之后是0，所以我们可以人为的给 $\sum$里面加上一个1，即：
$$ans=n\sum_{d|n}(\frac{\frac{n}{d}\phi(\frac{n}{d})}{2}+1)=n\sum_{d|n}\frac{\frac{n}{d}\phi(\frac{n}{d})}{2}+n$$
所以我们可以O(n)筛出欧拉函数，然后O( $nlog_2n$)预处理出 $\sum_{d|n}\frac{\frac{n}{d}\phi(\frac{n}{d})}{2}$，就可以做到单组询问O(1)．于是这道题就解决了．
代码：

#include<cstdio>
#include<algorithm>
using namespace std;

typedef long long LL;
const int maxn=1000010;
int T,phi[maxn],prime[maxn];
LL n,ans[maxn];
bool ok[maxn];

void Init(int x){
    phi[1]=1;
    for(int i=2;i<=x;i++){
        if(!ok[i]){
            prime[++prime[0]]=i;
            phi[i]=i-1;
        }
        for(int j=1;j<=prime[0]&&i*prime[j]<=x;j++){
            ok[i*prime[j]]=true;
            if(i%prime[j])phi[i*prime[j]]=phi[i]*(prime[j]-1);
            else{
                phi[i*prime[j]]=phi[i]*prime[j];
                break;
            }
        }
    }
    for(int i=1;i<=x;i++){
        for(int j=i;j<=x;j+=i){
            ans[j]+=(long long)phi[j/i]*(j/i)/2;
        }
    }
}

int main(){
    Init(1000000);
    scanf("%d",&T);
    while(T--){
        scanf("%lld",&n);
        printf("%lld\n",n*ans[n]+n);
    }
    return 0;
}