|
|
##[$AcWing$ $200$. $Hankson$的趣味题](https://www.acwing.com/problem/content/description/202/)
|
|
|
|
|
|
和 **[这道题](https://www.cnblogs.com/littlehb/p/15196071.html)** 是姊妹题关系，套路应该是一样的，无脑的写代码：
|
|
|
|
|
|
### 一、题目描述
|
|
|
$Hanks$ 博士是 $BT$（$Bio-Tech$，生物技术）领域的知名专家，他的儿子名叫 $Hankson$。
|
|
|
|
|
|
现在，刚刚放学回家的 $Hankson$ 正在思考一个有趣的问题。
|
|
|
|
|
|
今天在课堂上，老师讲解了如何求两个正整数 $c_1$ 和 $c_2$ 的最大公约数和最小公倍数。
|
|
|
|
|
|
现在 $Hankson$ 认为自己已经熟练地掌握了这些知识，他开始思考一个 **求公约数** 和 **求公倍数** 之类问题的 **逆问题**，这个问题是这样的：
|
|
|
|
|
|
|
|
|
已知正整数 $a_0,a_1,b_0,b_1$，设某未知正整数 $x$ 满足：
|
|
|
|
|
|
- $x$ 和 $a_0$ 的最大公约数是 $a_1$
|
|
|
- $x$ 和 $b_0$ 的最小公倍数是 $b_1$
|
|
|
|
|
|
$Hankson$ 的 **逆问题** 就是求出满足条件的正整数 $x$。
|
|
|
|
|
|
但稍加思索之后，他发现这样的 $x$ 并不唯一，甚至可能不存在。
|
|
|
|
|
|
因此他转而开始考虑如何求解满足条件的 $x$ 的个数。
|
|
|
|
|
|
请你帮助他编程求解这个问题。
|
|
|
|
|
|
|
|
|
**输入格式**
|
|
|
输入第一行为一个正整数 $n$，表示有 $n$ 组输入数据。
|
|
|
|
|
|
接下来的 $n$ 行每行一组输入数据，为四个正整数 $a_0，a_1，b_0，b_1$，每两个整数之间用一个空格隔开。
|
|
|
|
|
|
输入数据保证 $a_0$ 能被 $a_1$ 整除，$b_1$ 能被 $b_0$ 整除。
|
|
|
|
|
|
**输出格式**
|
|
|
输出共 $n$ 行。
|
|
|
|
|
|
每组输入数据的输出结果占一行，为一个整数。
|
|
|
|
|
|
对于每组数据：若不存在这样的 $x$，请输出 $0$；
|
|
|
|
|
|
若存在这样的 $x$，请输出满足条件的 $x$ 的个数；
|
|
|
|
|
|
**数据范围**
|
|
|
$1≤n≤2000,1≤a_0,a_1,b_0,b_1≤2∗10^9$
|
|
|
|
|
|
**输入样例**：
|
|
|
```cpp {.line-numbers}
|
|
|
2
|
|
|
41 1 96 288
|
|
|
95 1 37 1776
|
|
|
```
|
|
|
|
|
|
**输出样例**：
|
|
|
```cpp {.line-numbers}
|
|
|
6
|
|
|
2
|
|
|
```
|
|
|
|
|
|
|
|
|
### 二、前置知识
|
|
|
<font color='red'><b>以下性质，都是定义在整数范围内：</b></font>
|
|
|
#### 1、哪个数的约数最多，多少个？
|
|
|
其实就是求 **[反素数](https://www.cnblogs.com/littlehb/p/16292168.html)** 这个题，共$1600$个。**这个$1600$需要进行记忆**，有很多题在定义上限时需要用到。
|
|
|
|
|
|
#### 2、$1 \sim N$中任何数的不同质因子 <font color='red'><b>个数</b></font> 不会超过$9$个
|
|
|
因为$2×3×5×7×11×13×17×19×23×29>2×10^9$:
|
|
|
一个数，它可以有很大的质数因子，但不同的质数因子个数，按最小的计算都无法超过$9$个，大点的就更不可能超过$9$个了，否则就超过了`INT_MAX`
|
|
|
|
|
|
#### 3、枚举小质数因子需要到的上限值
|
|
|
|
|
|
```cpp {.line-numbers}
|
|
|
cout << sqrt(INT_MAX) << endl;
|
|
|
```
|
|
|
输出:`46341`,所以，一般开数组开到`50000`足够~
|
|
|
|
|
|
|
|
|
#### 4、枚举最大公约数的倍数
|
|
|
枚举$a_1$的倍数
|
|
|
$TLE$ $6/11$个数据
|
|
|
|
|
|
```cpp {.line-numbers}
|
|
|
#include <bits/stdc++.h>
|
|
|
using namespace std;
|
|
|
|
|
|
// 最大公约数
|
|
|
int gcd(int x, int y) {
|
|
|
return y ? gcd(y, x % y) : x;
|
|
|
}
|
|
|
|
|
|
// 最小公倍数
|
|
|
int lcm(int x, int y) {
|
|
|
return y / gcd(x, y) * x; // 注意顺序，防止乘法爆int
|
|
|
}
|
|
|
|
|
|
int main() {
|
|
|
// 输入
|
|
|
int n;
|
|
|
cin >> n;
|
|
|
// 最大2000次噢
|
|
|
while (n--) {
|
|
|
/*
|
|
|
读入四个数字
|
|
|
x 和 a0 的最大公约数是 a1
|
|
|
x 和 b0 的最小公倍数是 b1
|
|
|
*/
|
|
|
int a0, a1, b0, b1;
|
|
|
cin >> a0 >> a1 >> b0 >> b1;
|
|
|
// 每次记数器清0
|
|
|
int cnt = 0;
|
|
|
// 枚举a1的所有倍数
|
|
|
for (int x = a1; x <= b1; x += a1)
|
|
|
if (gcd(x, a0) == a1 && lcm(x, b0) == b1) cnt++;
|
|
|
|
|
|
printf("%d\n", cnt);
|
|
|
}
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
```
|
|
|
|
|
|
#### 5、枚举最小公倍数的约数
|
|
|
思考了下，为什么遍历倍数会大面积的$TLE$呢？
|
|
|
下载了测试点$2$的数据:
|
|
|
```cpp {.line-numbers}
|
|
|
2000
|
|
|
21222 2 999993719 1999987438
|
|
|
9034 2 999978442 1999956884
|
|
|
24921 1 999975441 1999950882
|
|
|
...
|
|
|
```
|
|
|
$b_1$很大，接近$2e9$，$a_1$很小，比如$1,2$,这样的极限数值，如果用在枚举倍数的时候，就会循环接近$2e9$次，不$tle$才是奇迹！说白了，就是出题人故意造成了些数据 **卡掉了枚举倍数方法**，铁了心 **让我们使用枚举约数的方法**。
|
|
|
|
|
|
同时，我们也认识到，枚举约数可以只运算到$1\sim \sqrt{b_1}$,数据量并不大，性能有保障，以后还是记住套路，<font color='red' size=4><b>尽量枚举最小公倍数的约数</b></font>，这样更靠谱些。
|
|
|
|
|
|
时间复杂度： $O(n\sqrt{b_1})$
|
|
|
|
|
|
由于 $[x,b_0]=b_1$，因此 $x$ 一定是 $b_1$ 的约数。
|
|
|
所以我们可以枚举 $b_1$ 的所有约数，然后依次判断是否满足 $[x,b_0]=b_1$ 以及 $(x,a_0)=a_1$ 即可。
|
|
|
|
|
|
如果直接用试除法求 $b_1$ 的所有约数，那么总计算量是
|
|
|
$n \sqrt{b_1}=2000∗ \sqrt{2×10^9}≈10^8$，会有一个测试数据超时。
|
|
|
|
|
|
```cpp {.line-numbers}
|
|
|
#include <bits/stdc++.h>
|
|
|
using namespace std;
|
|
|
|
|
|
// 最大公约数
|
|
|
int gcd(int a, int b) {
|
|
|
return b ? gcd(b, a % b) : a;
|
|
|
}
|
|
|
|
|
|
// 最小公倍数
|
|
|
int lcm(int a, int b) {
|
|
|
return b / gcd(a, b) * a; // 注意顺序，防止乘法爆int
|
|
|
}
|
|
|
|
|
|
int main() {
|
|
|
int T;
|
|
|
cin >> T;
|
|
|
while (T--) {
|
|
|
int ans = 0, a0, a1, b0, b1;
|
|
|
cin >> a0 >> a1 >> b0 >> b1;
|
|
|
/*
|
|
|
读入四个数字
|
|
|
x 和 a0 的最大公约数是 a1
|
|
|
x 和 b0 的最小公倍数是 b1
|
|
|
*/
|
|
|
for (int i = 1; i * i <= b1; i++) { // 枚举b1的所有约数
|
|
|
if (b1 % i) continue; // 是因数
|
|
|
if (gcd(i, a0) == a1 && lcm(i, b0) == b1) ans++; // 因数i符合要求
|
|
|
int j = b1 / i; // 另一个因子
|
|
|
if (gcd(j, a0) == a1 && lcm(j, b0) == b1 && i != j) ans++;
|
|
|
}
|
|
|
printf("%d\n", ans);
|
|
|
}
|
|
|
return 0;
|
|
|
}
|
|
|
```
|
|
|
|
|
|
### 五、优化思路
|
|
|
上面的代码，之所以最后两个测试点$TLE$,根本的原因在于$1 \sim \sqrt{n}$的因数试除！
|
|
|
有的不可能的因数，也进行了试除，需要$O(\sqrt{N})$的时间复杂度，这个是慢的原因。
|
|
|
> <font color='red' size=3><b> 注:好神奇，$2023$年$11$月$14$日再次看这道题时，发现上面的代码就可以直接$AC$了，不需要再优化了~</b></font>
|
|
|
|
|
|
|
|
|
下面尝试对这个$O(\sqrt{n})$的算法想办法进行优化：
|
|
|
|
|
|
那么我们应该如何 **快速求出$n$的所有约数** ？
|
|
|
|
|
|
- ① 欧拉筛 筛出$1\sim 50000$之间的所有质数（因为$50000^2>2×10^9$）
|
|
|
|
|
|
- ② 利用上面的所有质数数组，将$b1$分解质因数,生成$b1$质数因数有哪些，并且，每个质数因数有几个
|
|
|
```cpp {.line-numbers}
|
|
|
for (int i = 0; primes[i] <= t / primes[i]; i++) {
|
|
|
int p = primes[i];
|
|
|
if (t % p == 0) {
|
|
|
int s = 0;
|
|
|
while (t % p == 0) t /= p, s++;
|
|
|
f[fl++] = {p, s}; //记录小质数因子和个数
|
|
|
}
|
|
|
}
|
|
|
```
|
|
|
- ③ 现在得到的只是质数因子的信息，并不是我们想要的约数信息，还需要进行转化，怎么转化呢？使用$dfs$!
|
|
|
举个栗子：$24=2^3*3^1$，约数有$(1,2,3,4,6,8,12,24)$，可以视为
|
|
|
* $1 = 2^0 * 3^0$
|
|
|
* $2= 2^1 * 3^0$
|
|
|
* $3=2^0*3^1$
|
|
|
* $4=2^2*3^1$
|
|
|
* $6=2^1*3^1$
|
|
|
* $8=2^3*3^0$
|
|
|
* $12=2^2*3^1$
|
|
|
* $24=2^3*3^1$
|
|
|
我们用$dfs$方式枚举所有的组合情况，就可以得到$24$的所有约数数组！
|
|
|
|
|
|
```cpp {.line-numbers}
|
|
|
/**
|
|
|
功能：根据分解完成的质数因子数组 获取 所有约数
|
|
|
u：走到已经求出的质数因子数组f面前，现在是第u个
|
|
|
p: 已经拼接完成的的约数，初始值是1,是0的话没法通过质数因子相乘得到结果，base=1
|
|
|
*/
|
|
|
void dfs(int u, int p) {
|
|
|
if (u == fl) { // 如果所有质数因子遍历完成 0~fl-1是所有质因子的下标
|
|
|
d[dl++] = p; // 约数又多了一个
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
// 枚举当前质数因子f[u]使用几个,最少是0个，最多是f[u].count个
|
|
|
for (int i = 0; i <= f[u].count; i++) {
|
|
|
dfs(u + 1, p);
|
|
|
p *= f[u].prime; // 这两句话用的太漂亮了，完美的模拟了要0个，要1个，要2个...牛B plus!
|
|
|
}
|
|
|
}
|
|
|
```
|
|
|
|
|
|
|
|
|
#### $Code$
|
|
|
```cpp {.line-numbers}
|
|
|
#include <bits/stdc++.h>
|
|
|
using namespace std;
|
|
|
const int N = 50010;
|
|
|
typedef long long LL;
|
|
|
|
|
|
struct Node {
|
|
|
int prime; // 质数因子
|
|
|
int count; // 个数
|
|
|
} f[10]; // 一维：哪个质数因子，二维：有几个 f:因子
|
|
|
// 根据经验， primes[]={2,3,5,7,11,13,17,19,23}足够分解INT_MAX,共9个就够了
|
|
|
int fl; // 配合数组使用的游标
|
|
|
|
|
|
int d[1610], dl; // 约数数组,约数数组游标 d:约数
|
|
|
// 根据经验INT_MAX中约数个数最多的是1600个,开1610足够。
|
|
|
|
|
|
// 欧拉筛
|
|
|
int primes[N], cnt; // primes[]存储所有素数
|
|
|
bool st[N]; // st[x]存储x是否被筛掉
|
|
|
void get_primes(int n) {
|
|
|
memset(st, 0, sizeof st);
|
|
|
cnt = 0;
|
|
|
for (int i = 2; i <= n; i++) {
|
|
|
if (!st[i]) primes[cnt++] = i;
|
|
|
for (int j = 0; primes[j] * i <= n; j++) {
|
|
|
st[primes[j] * i] = true;
|
|
|
if (i % primes[j] == 0) break;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 最大公约数，辗转相除法
|
|
|
int gcd(int a, int b) {
|
|
|
if (b == 0) return a;
|
|
|
return gcd(b, a % b);
|
|
|
}
|
|
|
|
|
|
// 最小公倍数
|
|
|
int lcm(int a, int b) {
|
|
|
return b / gcd(a, b) * a; // 注意顺序，防止乘法爆int
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
功能：根据分解完成的质数因子数组 获取 所有约数
|
|
|
u：走到已经求出的质数因子数组f面前，现在是第u个
|
|
|
p: 已经拼接完成的的约数，初始值是1,是0的话没法通过质数因子相乘得到结果，base=1
|
|
|
*/
|
|
|
void dfs(int u, int p) {
|
|
|
if (u == fl) { // 如果所有质数因子遍历完成 0~fl-1是所有质因子的下标
|
|
|
d[dl++] = p; // 约数又多了一个
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
// 枚举当前质数因子f[u]使用几个,最少是0个，最多是f[u].count个
|
|
|
for (int i = 0; i <= f[u].count; i++) {
|
|
|
dfs(u + 1, p);
|
|
|
p *= f[u].prime; // 这两句话用的太漂亮了，完美的模拟了要0个，要1个，要2个...牛B plus!
|
|
|
}
|
|
|
}
|
|
|
|
|
|
int main() {
|
|
|
get_primes(50000); // 求小的质数因子，sqrt(INT_MAX)<50000,开50000很保险
|
|
|
|
|
|
int n;
|
|
|
cin >> n;
|
|
|
while (n--) {
|
|
|
/*
|
|
|
读入四个数字
|
|
|
x 和 a0 的最大公约数是 a1
|
|
|
x 和 b0 的最小公倍数是 b1
|
|
|
*/
|
|
|
int a0, a1, b0, b1;
|
|
|
cin >> a0 >> a1 >> b0 >> b1;
|
|
|
|
|
|
fl = 0; // 多组数据，每次注意清零
|
|
|
int t = b1; // 拷贝出来，一直除到没有为止
|
|
|
|
|
|
// 枚举b1的每个质数小因子
|
|
|
for (int i = 0; primes[i] <= t / primes[i]; i++) {
|
|
|
int p = primes[i];
|
|
|
if (t % p == 0) {
|
|
|
int s = 0;
|
|
|
while (t % p == 0) t /= p, s++;
|
|
|
f[fl++] = {p, s}; // 记录小质数因子和个数
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 如果存在大的质因子，那么最多只有一个，比如2*7=14中的7,此时t=7
|
|
|
// 也可能b1本身就是一个质数，比如131,那么此时t=131
|
|
|
if (t > 1) f[fl++] = {t, 1}; // 记录到质数数组中
|
|
|
|
|
|
// 现在求出的是b1的所有质数因数，题目要求的是约数,利用dfs通过质数因子获取所有约数
|
|
|
dl = 0; // 多组测试数据，也清一下零吧！
|
|
|
dfs(0, 1); // 一次dfs，将质数因子数组 转换 约数数组,p的默认值是1
|
|
|
|
|
|
int res = 0; // 答案数量
|
|
|
for (int i = 0; i < dl; i++) { // 枚举所有约数
|
|
|
int x = d[i]; // 判断是不是符合题意
|
|
|
if (gcd(a0, x) == a1 && lcm(b0, x) == b1) res++;
|
|
|
}
|
|
|
// 输出结果
|
|
|
printf("%d\n", res);
|
|
|
}
|
|
|
|
|
|
return 0;
|
|
|
}
|
|
|
```
|
|
|
|
