[SDOI2015]约数个数和

本文介绍了一种使用莫比乌斯反演解决特定数学问题的方法,即求解两个数乘积的约数个数之和。通过预处理μ函数前缀和与g(x)函数,实现了时间复杂度为O(T√x)的高效算法。

Description

TTT 组询问。
d(x)d(x)d(x)xxx 的约数个数,给定 NNNMMM,求 ∑i=1N∑j=1Md(ij)\sum_{i=1}^N \sum_{j=1}^M d(ij)i=1Nj=1Md(ij)
1≤n,m,T≤500001\le n, m, T\le 500001n,m,T50000

Solution

莫比乌斯反演即可:

∑n=1N∑m=1Md(nm)\sum_{n = 1}^{N} \sum_{m = 1}^{M} d(nm)n=1Nm=1Md(nm)

=∑n=1N∑m=1M∑a∣n∑b∣m[gcd(a,b)==1]=\sum_{n = 1}^{N} \sum_{m = 1}^{M} \sum_{a|n} \sum_{b|m} [gcd(a,b) == 1]=n=1Nm=1Manbm[gcd(a,b)==1]

=∑n=1N∑m=1M∑a∣n∑b∣m∑d∣gcd(a,b)μ(d)=\sum_{n = 1}^{N} \sum_{m = 1}^{M} \sum_{a|n} \sum_{b|m} \sum_{d|gcd(a,b)} \mu (d)=n=1Nm=1Manbmdgcd(a,b)μ(d)

=∑d=1min⁡{N,M}μ(d)∑a=1⌊Nd⌋∑b=1⌊Md⌋⌊Nad⌋⌊Mbd⌋=\sum_{d = 1}^{\min\{N,M\}} \mu (d) \sum_{a = 1}^{\left \lfloor \frac{N}{d}\right \rfloor} \sum_{b = 1}^{\left \lfloor \frac{M}{d}\right \rfloor} \left \lfloor \frac{N}{ad}\right \rfloor \left \lfloor \frac{M}{bd}\right \rfloor=d=1min{N,M}μ(d)a=1dNb=1dMadNbdM

=∑d=1min⁡{N,M}μ(d)∑a=1⌊Nd⌋⌊Nad⌋∑b=1⌊Md⌋⌊Mbd⌋=\sum_{d = 1}^{\min\{N,M\}} \mu (d) \sum_{a = 1}^{\left \lfloor \frac{N}{d}\right \rfloor}\left \lfloor \frac{N}{ad}\right \rfloor \sum_{b = 1}^{\left \lfloor \frac{M}{d}\right \rfloor} \left \lfloor \frac{M}{bd}\right \rfloor=d=1min{N,M}μ(d)a=1dNadNb=1dMbdMg(x)=∑i=1x⌊xi⌋g(x) = \sum_{i=1}^x \left \lfloor \frac{x}{i} \right \rfloorg(x)=i=1xix

预处理 g(x)g(x)g(x)μ\muμ 函数前缀和。

整除分块,时间复杂度 O(Tx)O(T\sqrt x)O(Tx)

Code

//Dlove's template
#include <algorithm>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
#define R register
#define ll long long
#define ull unsigned long long
#define db double
#define ld long double
#define sqr(_x) ((_x) * (_x))
#define Cmax(_a, _b) ((_a) < (_b) ? (_a) = (_b), 1 : 0)
#define Cmin(_a, _b) ((_a) > (_b) ? (_a) = (_b), 1 : 0)
#define Max(_a, _b) ((_a) > (_b) ? (_a) : (_b))
#define Min(_a, _b) ((_a) < (_b) ? (_a) : (_b))
#define Abs(_x) (_x < 0 ? (-(_x)) : (_x))
using namespace std;
namespace Dntcry
{
	char Bs[1 << 22], *Ss = Bs, *Ts = Bs;		
	#define getchar() (Ss == Ts && (Ts = (Ss = Bs)  + fread(Bs, 1, 1 << 22, stdin), Ss == Ts)  EOF : *Ss++) 
	inline int read()
	{
		R int a = 0, b = 1; R char c = getchar();
		for(; c < '0' || c > '9'; c = getchar()) (c == '-') ? b = -1 : 0;
		for(; c >= '0' && c <= '9'; c = getchar()) a = (a << 1) + (a << 3) + c - '0';
		return a * b;
	}
	inline ll lread()
	{
		R ll a = 0, b = 1; R char c = getchar();
		for(; c < '0' || c > '9'; c = getchar()) (c == '-') ? b = -1 : 0;
		for(; c >= '0' && c <= '9'; c = getchar()) a = (a << 1) + (a << 3) + c - '0';
		return a * b;
	}
	const int Maxn = 50010;
	int T, n, m;
	int Pri[Maxn], tot, mu[Maxn];
	int g[Maxn];
	bool vis[Maxn];
	int getv(R int x)
	{
		R int res = 0;
		for(R int i = 1, next = 0; i <= x; i = next + 1)
		{
			next = x / (x / i);
			res += (next - i + 1) * (x / i);
		}
		return res;
	}
	int Main()
	{
		mu[1] = 1;
		for(R int i = 2; i <= 50000; i++)
		{
			if(!vis[i]) Pri[++tot] = i, mu[i] = -1;
			for(R int j = 1; j <= tot && Pri[j] * i <= 50000; j++)
			{
				vis[i * Pri[j]] = 1;
				if(i % Pri[j] == 0)
				{
					mu[i * Pri[j]] = 0;
					break;
				}
				else mu[i * Pri[j]] = -mu[i];
			}
			mu[i] += mu[i - 1];
		}
		for(R int i = 1; i <= 50000; i++) g[i] = getv(i);
		T = read();
		while(T--)
		{
			n = read(), m = read();
			if(n > m) swap(n, m);
			R ll Ans = 0;
			for(R int i = 1, next = 0; i <= n; i = next + 1)
			{
				next = Min(n / (n / i), m / (m / i));
				Ans += 1ll * (mu[next] - mu[i - 1]) * g[n / i] * g[m / i];
			}
			printf("%lld\n", Ans);
		}
		return 0;
	}
}
int main()
{
	return Dntcry :: Main();
}
### 计算一个整数的约数个数及所有约数 要计算一个整数的约数个数及其所有约数,可以采用两种不同的方法:**暴力枚举法****质因数分解法**。后者在处理大整数时效率更高。 #### 暴力枚举法 对于一个正整数 $ n $,可以通过遍历从 1 到 $ \sqrt{n} $ 的所有整数来判断是否是其约数。 - **约数个数**:每找到一个小于 $ \sqrt{n} $ 的因数 $ i $,若 $ i \neq n/i $,则 $ n $ 同时具有 $ i $ $ n/i $ 两个因数,因此每次找到因数时可以将计数加 2;若 $ i = n/i $,则只加 1。 - **约数**:同理,每次找到因数时,将 $ i $ $ n/i $(如果不同)加入总中。 ```c #include <stdio.h> #include <math.h> int main() { int n, i, count = 0, sum = 0; printf("请输入一个整数:"); scanf("%d", &n); for (i = 1; i <= sqrt(n); i++) { if (n % i == 0) { if (i == n / i) { count += 1; sum += i; } else { count += 2; sum += i + n / i; } } } printf("约数个数:%d\n", count); printf("约数:%d\n", sum); return 0; } ``` 该方法适用于较小的整数,时间复杂度为 $ O(\sqrt{n}) $。 #### 质因数分解法 若已知整数 $ n $ 的质因数分解为: $$ n = p_1^{a_1} \cdot p_2^{a_2} \cdot \ldots \cdot p_k^{a_k} $$ 则: - **约数个数**:$$ \text{count} = (a_1 + 1)(a_2 + 1)\ldots(a_k + 1) $$ - **约数**:$$ \text{sum} = (1 + p_1 + p_1^2 + \ldots + p_1^{a_1})(1 + p_2 + p_2^2 + \ldots + p_2^{a_2})\ldots(1 + p_k + p_k^2 + \ldots + p_k^{a_k}) $$ 例如,对于 $ n = 20 = 2^2 \cdot 5^1 $,其约数个数为 $ (2+1)(1+1) = 6 $,约数为 $ (1+2+4)(1+5) = 7 \cdot 6 = 42 $ [^2]。 该方法适用于已知质因数分解的场景,计算效率更高。 #### 示例:质因数分解后计算 ```python def divisor_count_and_sum(n): count = 1 sum_divisors = 1 i = 2 while i * i <= n: exponent = 0 while n % i == 0: n //= i exponent += 1 count *= (exponent + 1) sum_powers = 0 for j in range(exponent + 1): sum_powers += i ** j sum_divisors *= sum_powers i += 1 if n > 1: count *= 2 sum_divisors *= (1 + n) return count, sum_divisors # 示例 print(divisor_count_and_sum(20)) # 输出:(6, 42) ``` ###
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值