bzoj2818 欧拉函数、莫比乌斯反演

转载请注明出处，谢谢http://blog.csdn.net/bigtiao097?viewmode=contents

题意：

给定整数 n，求1<=x,y<=n$(1\leq n\leq 10^7)$且gcd(x,y)为素数的数对(x,y)有多少对.

思路：

• 思路一：
  $$gcd(x,y)=p\Longleftrightarrow gcd(x/p,y/p)=1$$
  $\ \ \ \ \ $我们先假设是有序对，不妨设$x<y\ $枚举上式中的素数p,对于每一个p，枚举$y/p 的值(1\leq y/p \leq n/p)\ $,计算x/p有多少种可能，然后累和，这里的x/p的可能数即为比y/p小且与y/p互素的数的个数（欧拉函数）,因为根据上式$x/p与y/p\ $是互素的
  $\ \ \ \ \ $但是上述做法会超时，我们需要提前处理好$欧拉函数\varphi (x) 的前缀和$,这样枚举素数p，对于每个p，我们可以O(1)的求出对答案的贡献
  $\ \ \ \ \ $最后一点需要注意的是(p,p)这样的也符合
• 思路二：
  莫比乌斯最典型也是最简单的应用
  $$g(n) = \sum_{n|d} f(d) \Longleftrightarrow f(n) = \sum _{n|d} \mu(\frac{d}{n})g(d)$$
  设$f(n)$代表$\ \ \ gcd(x,y)=n\ \ \ 的（x，y）的对数$
  设$g(n) 代表 gcd(x,y)\%n =0 \ \ 的（x，y）的对数$
  这样就有了 $$g(n) = \sum_{n|d} f(d)$$
  然后利用反演公式，因为$g(n)$非常的好求，$g(n) = \frac{max\_x}{n}\times \frac{max\_y}{n}$
  有了这些就好说了，对于每一个素数p，根据上述的反演公式直接计算就可以了

最后有一点要说的是，在bzoj上交题，跑素筛、欧拉函数、mobius函数之类的预处理时，不要总跑maxn这么大的，读入n后需要多大跑多大，否则可能会超时
还有就是printf时long long的占位符不要用%I64d，要用%lld，否则会WA

---

具体代码如下：
代码一
Result：Accepted $\ \ \ $Memory: 122380Kb $\ \ \ $Time : 2656 ms

#include<bits/stdc++.h>
typedef long long ll;
using namespace std;
const int maxn=1e7+5;
int phi[maxn];
ll sum[maxn];
ll ans;
int n;
int prime[maxn/10] = {0},cnt = 0;
void euler_init(int n)
{
    for(int i=1;i<=n;i++) phi[i]=i;
    for(int i=2;i<=n;i++)
        if(phi[i]==i)
        {
            for(int j=i;j<=n;j+=i)
                phi[j]=phi[j]/i*(i-1);
            prime[cnt++] = i;
        }
}
int main()
{
    cin>>n;
    euler_init(n);
    for(int i=2;i<=n;i++)
        sum[i] = sum[i-1]+phi[i]*2;
    for(int i=0;i<cnt&&prime[i]<=n;i++)
        ans+= 1+sum[n/prime[i]];
    cout<<ans<<endl;

}

代码二
Result：Accepted $\ \ \ $Memory: 89180 kb $\ \ \ $Time : 3164 ms

#include<bits/stdc++.h>
typedef long long ll;
using namespace std;
const int maxn=1e7+5;
bool vis[maxn];
int prime[maxn];
int mu[maxn];
int n;
int tot;
ll ans;
ll cur;
void mobius(int n)
{
    memset(vis,0,sizeof vis);
    mu[1] = 1;
    tot = 0;
    for(int i = 2; i <=n; i++)
    {
        if( !vis[i] ){
            prime[tot++] = i;
            mu[i] = -1;
        }
        for(int j = 0; j < tot; j++)
        {
            if(i * prime[j] > n) break;
            vis[i * prime[j]] = true;
            if( i % prime[j] == 0)
            {
                mu[i * prime[j]] = 0;
                break;
            }
            else
                mu[i * prime[j]] = -mu[i];
        }
    }
}
int main()
{
    cin>>n;
    mobius(n);
    for(int i=0;i<tot&&prime[i]<=n;i++)
    {
        cur = prime[i];
        for(int d=cur;d<=n;d+=cur)
            ans+= 1LL*mu[d/cur]*(n/d)*(n/d);
    }
    cout<<ans<<endl;

}

莫比乌斯反演的方法还可以进行分段优化
这里不详细解释了，代码如下：
Result：Accepted $\ \ \ $Memory: 89180 kb $\ \ \ $Time : 1104 ms

#include<bits/stdc++.h>
typedef long long ll;
using namespace std;
const int maxn=1e7+5;
bool vis[maxn];
int prime[maxn];
int mu[maxn];
int n;
int tot;
ll ans;
ll cur;
void mobius(int n)
{
    memset(vis,0,sizeof vis);
    mu[1] = 1;
    tot = 0;
    for(int i = 2; i <=n; i++)
    {
        if( !vis[i] ){
            prime[tot++] = i;
            mu[i] = -1;
        }
        for(int j = 0; j < tot; j++)
        {
            if(i * prime[j] > n) break;
            vis[i * prime[j]] = true;
            if( i % prime[j] == 0)
            {
                mu[i * prime[j]] = 0;
                break;
            }
            else
                mu[i * prime[j]] = -mu[i];
        }
    }
    for(int i=2;i<=n;i++)
        mu[i]+=mu[i-1];
}
ll solve(int a,int b)
{
    ll res = 0;
    if(a>b)swap(a,b);
    for(int i=1,nex;i<=a;i=nex+1)
    {
        nex = min(a/(a/i),b/(b/i));
        res += 1LL *(mu[nex]-mu[i-1])*(a/i)*(b/i);
    }
    return res;
}
int main()
{
    cin>>n;
    mobius(n);
    for(int i=0;i<tot&&prime[i]<=n;i++)
    {
        cur = prime[i];
        ans+=solve(n/cur,n/cur);
    }
    cout<<ans<<endl;

}