BZOJ2693(BZOJ2154)——莫比乌斯反演经典例题

题目链接：https://www.lydsy.com/JudgeOnline/problem.php?id=2154

题意理解：

给你n和m，求所有的lcm(i,j)之和，1<=i<=n,1<=j<=m;

很经典的莫比乌斯反演例题，从这里能真正发现它的牛皮之处。

学习这个算法需要有一点预备的知识，数论分块和唯一分解定理。

关于数论分块这里有一篇很不错的文章：https://www.cnblogs.com/henry-1202/p/10121854.html

其实原理很好理解，就是枚举对象变了，同时利用函数部分区间值相等的性质进行优化，大概可以优化到O（sqrt（n））.

唯一分解定理可以去百度一下，其实就是任意一个数都可以被拆成质数相乘的性质。

先简单的讲一下莫比乌斯反演，其实就两个公式，最常用的也就一个。

具体内容可以参考这个大佬的博客：https://www.cnblogs.com/cjyyb/p/8305710.html

注意一定要自己推一下公式，写一下，并且想一下为什么

然后推导过程不是很清楚的可以去b站上搜。

这个讲的虽然有点乱，但是当你感觉自己差不多懂的时候，再看这个可能就会恍然大悟！！！

https://www.bilibili.com/video/av65332506?from=search&seid=15426952177651991228

（我花了两天才把莫比乌斯反演看懂！！QWQ！）

然后就可以做这两道题了，其实和求最大公约数的有点类似。

---

下面开始真正说说这个题，

通常方法时要枚举i和j的话时O(nm)复杂度的，肯定不能接受。

之后学了莫比乌斯反演我们可以通过化简，套公式变成O(min(n,m))，不过需要两次数论分块优化。

具体过程请参考：https://www.cnblogs.com/cjyyb/p/8253033.html

然后有的题的范围是1e10的范围，这样时间复杂度肯定是过不去的，因此我们要尝试进一步的优化，

这时需要用到积性函数的性质，然后预处理前缀和，在对每次询问进行O（sqrt（n））的回答。

详解请参考：https://www.cnblogs.com/cjyyb/p/8267797.html

这个题还有一个拓展题目（51nod1238），需要用到杜教筛来进行空间的优化。

先上O（min(n,m)）时间复杂度的代码实现

#include
#include
#include
#include
#include
#define rp(i,s, t) for (i = s; i <= t; i++)
#define RP(i,s, t) for (i = t; i >= s; i--)
#define ll long long
#define ull unsigned long long
using namespace std;
inline int read()
{
    int x=0,t=1;char ch=getchar();
    while((ch<'0'||ch>'9')&&ch!='-')ch=getchar();
    if(ch=='-')t=-1,ch=getchar();
    while(ch<='9'&&ch>='0')x=x*10+ch-48,ch=getchar();
    return x*t;
}
inline void write(int x)
{
    char F[200];
    int tmp=x>0?x:-x ;
    if(x<0)putchar('-') ;
    int cnt=0 ;
       while(tmp>0)
       {
           F[cnt++]=tmp%10+'0';
           tmp/=10;
       }
       while(cnt>0)putchar(F[--cnt]) ;
}
const int maxn=12000000;
const int MOD=20101009;
int mu[maxn],prime[maxn],visited[maxn];
int sum[maxn],sqr[maxn];
int tot;
int n,m;
void get_mu(){//求莫比乌斯函数μ，并且预处理求出μ的前缀和
	tot=0;
	memset(visited,0,sizeof visited);
	mu[1]=1;
	int i,j;
	rp(i,2,n){
		if(!visited[i]){
			visited[i]=1;
			mu[i]=-1;
			prime[tot++]=i;
		}
		rp(j,0,tot-1){
			if(prime[j]*i>n) break;
			visited[prime[j]*i]=1;
			if(i%prime[j]==0){
				mu[i*prime[j]]=0;
				break;
			}
			else{
				mu[i*prime[j]]=-mu[i];
			}
		}
	}
	rp(i,1,n) sum[i]=(sum[i-1]+mu[i]+MOD)%MOD;
}
int Solve(int x,int y){
	ll res=0;
	int i=1,j;
	while(i<=x){//数论分块
		j=min(x/(x/i),y/(y/i));
		int temp=1ll*(1ll*(1+x/i)*(x/i)/2%MOD)*(1ll*(1+y/i)*(y/i)/2%MOD)%MOD;//求两个等差数列的乘积
		res=(res+1ll*(sqr[j]-sqr[i-1])%MOD*temp%MOD)%MOD;
		i=j+1;
	}
	return  (res+MOD)%MOD;
}
int main(){
	n=read(),m=read();
	int i,j;
	if(n>m) swap(n,m);
	get_mu();
	rp(i,1,n) sqr[i]=(sqr[i-1]+1ll*i*i%MOD*mu[i]%MOD+MOD)%MOD;
	//预处理求出μ(i)*i*i的前缀和
	i=1;
	int ans=0;
	while(i<=n){//数论分块
		j=min(n/(n/i),m/(m/i));
		ll temp=1ll*(i+j)*(j-i+1)/2%MOD;
		ans=(ans+1ll*Solve(n/i,m/i)*temp%MOD)%MOD;
		i=j+1;
	}
	write(ans);
	return 0;
}

之后是O（sqrt（n））的代码实现（杜教筛还不会，过几天再补）

#include 
#include 
#include 
#include 
#include 
#define rp(i, s, t) for (i = s; i <= t; i++)
#define RP(i, s, t) for (i = t; i >= s; i--)
#define ll long long
#define ull unsigned long long
using namespace std;
inline int read()
{
    int x = 0, t = 1;
    char ch = getchar();
    while ((ch < '0' || ch > '9') && ch != '-')
        ch = getchar();
    if (ch == '-')
        t = -1, ch = getchar();
    while (ch <= '9' && ch >= '0')
        x = x * 10 + ch - 48, ch = getchar();
    return x * t;
}
inline void write(int x)
{
    char F[200];
    int tmp = x > 0 ? x : -x;
    if (x < 0)
        putchar('-');
    int cnt = 0;
    while (tmp > 0)
    {
        F[cnt++] = tmp % 10 + '0';
        tmp /= 10;
    }
    while (cnt > 0)
        putchar(F[--cnt]);
}
const int N = 15000000;
const int MOD = 100000009;
int visited[N + 10], prime[N + 10], sum[N + 10];
int tot;
int n, m;
void init()
{
    int i, j;
    sum[1] = 1;
    visited[1] = 1;
    rp(i, 2, N)
    {
        if (!visited[i])
        {
            sum[i] = (i - 1ll * i * i % MOD + MOD) % MOD;
            prime[tot++] = i;
        }
        rp(j, 0, tot - 1)
        {
            if (prime[j] * i >= N)
                break;
            visited[prime[j] * i] = 1;
            if (i % prime[j] == 0)
            {
                sum[prime[j] * i] = 1ll * sum[i] * prime[j] % MOD;
                break;
            }
            else
            {
                sum[prime[j] * i] = 1ll * sum[i] * sum[prime[j]] % MOD;
            }
        }
    }
    rp(i, 1, N) sum[i] = (sum[i - 1] + sum[i]) % MOD;
}
int main()
{
    int T = read();
    init();
    while (T--)
    {
        n = read();
        int i = 1, j;
        ll ans = 0;
        while (i <= n)
        {
            int j = n / (n / i);
            int temp = (1ll * (n / i) * (n / i + 1) / 2 % MOD) * (1ll * (n / i) * (n / i + 1) / 2 % MOD) % MOD;
            ans += 1ll * (sum[j] - sum[i - 1] + MOD) % MOD * temp % MOD;
            ans %= MOD;
            i = j + 1;
        }
        cout << (ans + MOD) % MOD << endl;
    }
    return 0;
}