莫比乌斯反演 两种形式

莫比乌斯反演在数论中占有重要的地位，许多情况下能大大简化运算。那么我们先来认识莫比乌斯反演公式。

 

定理：

和

是定义在非负整数集合上的两个函数，并且满足条件

，那么我们得到结论

 

     


 

在上面的公式中有一个

函数，它的定义如下：

 

    （1）若

，那么


    （2）若

，

均为互异素数，那么


    （3）其它情况下


 

 

对于

函数，它有如下的常见性质：

 

    （1）对任意正整数

有

  

                            


 

        （2）对任意正整数

有

 

         


 

线性筛选求莫比乌斯反演函数代码。

[cpp] view
plaincopy





void Init()  

{  

    memset(vis,0,sizeof(vis));  

    mu[1] = 1;  

    cnt = 0;  

    for(int i=2; i<N; i++)  

    {  

        if(!vis[i])  

        {  

            prime[cnt++] = i;  

            mu[i] = -1;  

        }  

        for(int j=0; j<cnt&&i*prime[j]<N; j++)  

        {  

            vis[i*prime[j]] = 1;  

            if(i%prime[j]) mu[i*prime[j]] = -mu[i];  

            else  

            {  

                mu[i*prime[j]] = 0;  

                break;  

            }  

        }  

    }  

}  

 

有了上面的知识，现在我们来证明莫比乌斯反演定理。

 

证明

 





 

证明完毕！

 

嗯，有了莫比乌斯反演，很多问题都可以简化了，接下来我们来看看莫比乌斯反演在数论中如何简化运算的。

 

 

题目：http://bz.cdqzoi.com/JudgeOnline/problem.php?id=2818

 

题意：给一个正整数

，其中

，求使得

为质数的

的个数，

。

 

分析：对于本题，因为是使得

为质数，所以必然要枚举小于等于

的质数，那么对于每一个质数

，只

     需要求在区间

中，满足有序对

互质的对数。

 

     也就是说，现在问题转化为：在区间

中，存在多少个有序对使得

互质，这个问题就简单啦，因为

     是有序对，不妨设

，那么我们如果枚举每一个

，小于

有多少个

与

互素，这正是欧拉函数。所以

     我们可以递推法求欧拉函数，将得到的答案乘以2即可，但是这里乘以2后还有漏计算了的，那么有哪些呢？

     是

且为素数的情况，再加上就行了。

 

代码：

[cpp] view
plaincopy





#include <iostream>  

#include <string.h>  

#include <stdio.h>  

#include <bitset>  

  

using namespace std;  

typedef long long LL;  

const int N = 10000010;  

  

bitset<N> prime;  

LL phi
;  

LL f
;  

int p
;  

int k;  

  

void isprime()  

{  

    k = 0;  

    prime.set();  

    for(int i=2; i<N; i++)  

    {  

        if(prime[i])  

        {  

            p[k++] = i;  

            for(int j=i+i; j<N; j+=i)  

                prime[j] = false;  

        }  

    }  

}  

  

void Init()  

{  

    for(int i=1; i<N; i++)  phi[i] = i;  

    for(int i=2; i<N; i+=2) phi[i] >>= 1;  

    for(int i=3; i<N; i+=2)  

    {  

        if(phi[i] == i)  

        {  

            for(int j=i; j<N; j+=i)  

                phi[j] = phi[j] - phi[j] / i;  

        }  

    }  

    f[1] = 0;  

    for(int i=2;i<N;i++)  

        f[i] = f[i-1] + (phi[i]<<1);  

}  

  

LL Solve(int n)  

{  

    LL ans = 0;  

    for(int i=0; i<k&&p[i]<=n; i++)  

        ans += 1 + f[n/p[i]];  

    return ans;  

}  

  

int main()  

{  

    Init();  

    isprime();  

    int n;  

    scanf("%d",&n);  

    printf("%I64d\n",Solve(n));  

    return 0;  

}  

 

嗯，上题不算太难，普通的欧拉函数就可以搞定，接下来我们来看看它的升级版。

 

题意：给定两个数

和

，其中

，

，求

为质数的

有多少对？其中

和

的范

     围是

。

 

分析：本题与上题不同的是

和

不一定相同。在这里我们用莫比乌斯反演来解决，文章开头也说了它能大大简化

     运算。我们知道莫比乌斯反演的一般描述为：

 

     


 

     其实它还有另一种描述，本题也是用到这种。那就是：

 

     


 

     好了，到了这里，我们开始进入正题。。。

 

     对于本题，我们设

 

     

为满足

且

和

的

的对数

     

为满足

且

和

的

的对数

 

     那么，很显然

，反演后得到


 

     因为题目要求是

为质数，那么我们枚举每一个质数

，然后得到

 

     


 

     如果直接这样做肯定TLE，那么我们必须优化。

 

     我们设

，那么继续得到

。

 

     到了这里，可以看出如果我们可以先预处理出所有的

对应的

的值，那么本题就解决了。

 

     我们设

，注意这里

为素数，

。

 

     那么，我们枚举每一个

，得到

，现在分情况讨论：

 

     （1）如果

整除

，那么得到

 

       


 

     （2）如果

不整除

，那么得到

 

       


 

[cpp] view
plaincopy





#include <iostream>  

#include <string.h>  

#include <stdio.h>  

  

using namespace std;  

typedef long long LL;  

const int N = 10000005;  

  

bool vis
;  

int p
;  

int cnt;  

int g
,u
,sum
;  

  

void Init()  

{  

    memset(vis,0,sizeof(vis));  

    u[1] = 1;  

    cnt = 0;  

    for(int i=2;i<N;i++)  

    {  

        if(!vis[i])  

        {  

            p[cnt++] = i;  

            u[i] = -1;  

            g[i] = 1;  

        }  

        for(int j=0;j<cnt&&i*p[j]<N;j++)  

        {  

            vis[i*p[j]] = 1;  

            if(i%p[j])  

            {  

                u[i*p[j]] = -u[i];  

                g[i*p[j]] = u[i] - g[i];  

            }  

            else  

            {  

                u[i*p[j]] = 0;  

                g[i*p[j]] = u[i];  

                break;  

            }  

        }  

    }  

    sum[0] = 0;  

    for(int i=1;i<N;i++)  

        sum[i] = sum[i-1] + g[i];  

}  

  

int main()  

{  

    Init();  

    int T;  

    scanf("%d",&T);  

    while(T--)  

    {  

        LL n,m;  

        cin>>n>>m;  

        if(n > m) swap(n,m);  

        LL ans = 0;  

        for(int i=1,last;i<=n;i=last+1)  

        {  

            last = min(n/(n/i),m/(m/i));  

            ans += (n/i)*(m/i)*(sum[last]-sum[i-1]);  

        }  

        cout<<ans<<endl;  

    }  

    return 0;  

}