0x37 ZAP (Mobius）

最新推荐文章于 2020-08-18 14:42:19 发布

原创最新推荐文章于 2020-08-18 14:42:19 发布 · 241 阅读

0 ·

CC 4.0 BY-SA版权

———数学知识——— 同时被 3 个专栏收录

23 篇文章

订阅专栏

算法竞赛进阶指南刷题

23 篇文章

订阅专栏

莫比乌斯反演

2 篇文章

订阅专栏

本文深入探讨了Mobius反演在解决数论问题中的应用，特别是通过容斥原理和莫比乌斯函数，将复杂的数学问题转化为更易处理的形式。文章详细解释了如何使用Mobius反演来简化求解特定数论问题的过程，并提供了具体的算法实现，包括时间复杂度的优化。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

看着蓝书就入了 $M o b i u s$ 反演的坑了（但是蓝书并没有提到反演二字

首先根据基本的数论常识，我们知道 $∑x=1a∑y=1b[gcd⁡(x,y)=k]\sum\limits_{x=1}^a\sum\limits_{y=1}^b[\gcd(x,y)=k]$ 等价于 $∑x=1ak∑y=1bk[gcd⁡(x,y)=1]\sum\limits_{x=1}^\frac{a}{k}\sum\limits_{y=1}^\frac{b}{k}[\gcd(x,y)=1]$

令 $D [a, b, k]$ 表示 $∑x=1a∑y=1b[k∣gcd⁡(x,y)]\sum\limits_{x=1}^a\sum\limits_{y=1}^b[k|\gcd(x,y)]$ , 上述式子只需要满足 $x, y$ 均为 $k$ 的倍数即可，那么答案就是 $⌊ak⌋⌊bk⌋\lfloor\frac{a}{k} \rfloor\lfloor \frac{b}{k} \rfloor$

考虑答案怎么求。设 $F [a, b]$ 表示 $∑x=1a∑y=1b[gcd⁡(x,y)=1]\sum\limits_{x=1}^a\sum\limits_{y=1}^b[\gcd(x,y)=1]$

该式如何化简？我们思考怎么通过 $D$ 表示出 $F$

没有任何限制的时候 $x, y$ 的取值方法有 $D [a, b, 1] = a * b$ 种。

而上式显然应该减去 $gcd⁡\gcd$ 为 $2, 3, 5, . . . .$ 等的倍数的

但是 $gcd⁡\gcd$ 为 $2 * 3, 3 * 5$ 等倍数的被减去了两次，应该在加回来

那么我们就知道了可以通过容斥原理表示该式

$F[a,b]=∑i=1min⁡(a,b)x∗D[a,b,i]F[a,b]=\sum\limits_{i=1}^{\min(a,b)} x*D[a,b,i]$

但是这个 $x$ 到底该如何判定？

根据上面的推演，我们发现如果一个数的质因子分解式存在偶数个质因子，贡献为 $+$ ，若果有奇数个，贡献为 $-$ ，如果有一项指数 $> 1$ , 没有贡献

这不就是莫比乌斯函数？

最终 $F$ 就可被表示成这样：

$F[a,b]=∑i=1min⁡(a,b)μ(i)∗D[a,b,i]F[a,b]=\sum\limits_{i=1}^{\min(a,b)} \mu(i)*D[a,b,i]$

上述式子直接暴力求，是 $O(Tmin⁡(a,b))O(T\min(a,b))$ 的，肯定 $T L E$

怎么优化枚举？

我们发现 $D$ 数组的表示是 $⌊ai⌋⌊bi⌋\lfloor\frac{a}{i} \rfloor\lfloor \frac{b}{i} \rfloor$

这个式子长得一副整除分块的样子，同一个块答案相同，可以视为一体，再乘上该区间的莫比乌斯函数和，用前缀和维护就行了

时间复杂度 $O(T(a+b))O(T(\sqrt a + \sqrt b))$ ，可以通过测试

好像用线性筛在 $A c W i n g$ 也无法通过前部数据，就弃疗了

#include <map>
#include <set>
#include <ctime>
#include <queue>
#include <stack>
#include <cmath>
#include <vector>
#include <bitset>
#include <cstdio>
#include <cctype>
#include <string>
#include <numeric>
#include <cstring>
#include <cassert>
#include <climits>
#include <cstdlib>
#include <iostream>
#include <algorithm>
#include <functional>
using namespace std ;
#define int long long
#define rep(i, a, b) for (int i = (a); i <= (b); i++)
#define per(i, a, b) for (int i = (a); i >= (b); i--)
#define loop(s, v, it) for (s::iterator it = v.begin(); it != v.end(); it++)
#define cont(i, x) for (int i = head[x]; i; i = e[i].nxt)
#define clr(a) memset(a, 0, sizeof(a))
#define ass(a, sum) memset(a, sum, sizeof(a))
#define lowbit(x) (x & -x)
#define all(x) x.begin(), x.end()
#define mp make_pair
#define pb push_back
#define fi first
#define se second
#define iv inline void
#define enter cout << endl
#define siz(x) ((int)x.size())
#define file(s) freopen(s".in", "r", stdin), freopen(s."out", "w", stdout)
typedef long long ll ;
typedef unsigned long long ull ;
typedef pair <int, int> pii ;
typedef vector <int> vi ;
typedef vector <pii> vii ;
typedef queue <int> qi ;
typedef set <int> si ;
typedef map <int, int> mii ;
typedef map <string, int> msi ;
const int N = 50010 ;
const int INF = 0x3f3f3f3f ;
const int iinf = 1 << 30 ;
const ll linf = 2e18 ;
const int MOD = 1000000007 ;
const double eps = 1e-7 ;
void print(int x) { cout << x << endl ; exit(0) ; }
void PRINT(string x) { cout << x << endl ; exit(0) ; }
void douout(double x){ printf("%lf\n", x + 0.0000000001) ; }

int vis[N], prime[N], miu[N] ;
ll sum[N] ;
int T, a, b, d, cnt ;
ll ans ;

/*
void sieve(int n) {
	rep(i, 1, n) miu[i] = 1, v[i] = 0 ;
	rep(i, 2, n) {
		if (v[i]) continue ;
		miu[i] = -1 ;
		for (int j = 2 * i; j <= n; j += i) {
			v[j] = 1 ;
			if ((j / i) % i == 0) miu[j] = 0 ; // 有一个质因子大小大于1
			else miu[j] *= -1 ;
		}
	}
	rep(i, 1, n) sum[i] = sum[i - 1] + miu[i] ;
}
*/

void sieve(int n) {
	miu[1] = 1 ;
	rep(i, 2, n) {
		if (!vis[i]) {
			miu[i] = -1 ;
			prime[++cnt] = i ;
		}
		for (int j = 1; j <= cnt && i * prime[j] <= n; j++) {
			vis[i * prime[j]] = 1 ;
			if (i % prime[j] == 0) break ;
			else miu[i* prime[j]] -= miu[i] ;
		}
	}
	rep(i, 1, n) sum[i] = sum[i - 1] + miu[i] ;
}

signed main(){
	scanf("%lld", &T) ;
	sieve(50000) ;
	while (T--) {
		scanf("%lld%lld%lld", &a, &b, &d); ans = 0 ;
		a /= d, b /= d ;
		for (int l = 1, r; l <= min(a, b); l = r + 1) {
			r = min(a / (a / l), b / (b / l)) ;
			ans += (a / l) * (b / l) * (sum[r] - sum[l - 1]) ;
		}
		printf("%lld\n", ans) ;
	}
	return 0 ;
}

/*
写代码时请注意：
	1.ll？数组大小，边界？数据范围？
	2.精度？
	3.特判？
	4.至少做一些
思考提醒：
	1.最大值最小->二分？
	2.可以贪心么？不行dp可以么
	3.可以优化么
	4.维护区间用什么数据结构？
	5.统计方案是用dp？模了么？
	6.逆向思维？
*/