0x37 ZAP (Mobius）

看着蓝书就入了 $Mobius$ 反演的坑了（但是蓝书并没有提到反演二字

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

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

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

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

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

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

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

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

$F[a,b]=\sum _{i=1}^{\min (a,b)}x\ast D[a,b,i]$

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

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

这不就是莫比乌斯函数？

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

$F[a,b]=\sum _{i=1}^{\min (a,b)}\mu (i)\ast D[a,b,i]$

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

怎么优化枚举？

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

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

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

好像用线性筛在 $AcWing$ 也无法通过前部数据，就弃疗了

#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.逆向思维？
*/