200 Hankson的趣味题（暴力枚举优化）

1. 问题描述：

Hanks 博士是 BT（Bio-Tech，生物技术）领域的知名专家，他的儿子名叫 Hankson。现在，刚刚放学回家的 Hankson 正在思考一个有趣的问题。今天在课堂上，老师讲解了如何求两个正整数 c1 和 c2 的最大公约数和最小公倍数。现在 Hankson 认为自己已经熟练地掌握了这些知识，他开始思考一个"求公约数"和"求公倍数"之类问题的"逆问题"，这个问题是这样的：已知正整数 a0，a1，b0，b1，设某未知正整数 x 满足：x 和 a0 的最大公约数是 a1；x 和 b0 的最小公倍数是 b1。Hankson 的"逆问题"就是求出满足条件的正整数 x。但稍加思索之后，他发现这样的 x 并不唯一，甚至可能不存在。因此他转而开始考虑如何求解满足条件的 x 的个数。请你帮助他编程求解这个问题。

输入格式

输入第一行为一个正整数 n，表示有 n 组输入数据。接下来的 n 行每行一组输入数据，为四个正整数 a0，a1，b0，b1，每两个整数之间用一个空格隔开。输入数据保证 a0 能被 a1 整除，b1 能被 b0 整除。

输出格式

输出共 n 行。每组输入数据的输出结果占一行，为一个整数。对于每组数据：若不存在这样的 x，请输出 0；若存在这样的 x，请输出满足条件的 x 的个数；

数据范围

1 ≤ n ≤ 2000，
1 ≤ a0，a1, b0，b1 ≤ 2 ∗ 10 ^ 9

输入样例：
2
41 1 96 288
95 1 37 1776

输出样例：
6
2
来源：https://www.acwing.com/problem/content/description/202/

2. 思路分析：

设输入的四个整数分别为a，b，c，d，一个比较直观的想法是枚举d的所有约数，然后判断a和d的约数x的最大公约数是否是b，c和x的最小公倍数是否是d，因为这道题目卡时间所以这样做会超时，最多有2000组数据，如果使用试除法求解d的所有约数的时间复杂度为O(√n) ≈ 10 ^ 5，所以总的时间复杂度为10 ^ 8，所以是一定会超时的，我们需要优化枚举d的所有约数的瓶颈，这里有一个小技巧，不是从2一直枚举到√n，我们先可以预处理出1~50000（√2 * 10 ^ 9）之内的质因子，然后对d分解成若干个质因子对应的次数相乘将结果存储起来，暴力枚举质因子的次数得到对应的约数，最后枚举一下所有得到的约数判断是否满足题目中的两个条件，如果满足则计数加1。

3. 代码如下：

python（有时候会超时）：

from typing import List


class Solution:
    count = 0

    def init(self, n: int, primes: List[int], st: List[int]):
        for i in range(2, n):
            if st[i] == 0:
                primes[self.count] = i
                self.count += 1
            j = 0
            while i * primes[j] < n:
                st[i * primes[j]] = 1
                if i % primes[j] == 0: break
                j += 1

    # 求解a, b的最大公约数
    def gcd(self, a: int, b: int):
        return a if b == 0 else self.gcd(b, a % b)

    # 求解d的所有约数(之前已经求解出了d的所有质因子以及对应的出现次数所以只需要暴力枚举即可)
    def dfs(self, u: int, n: int, p: int, factor: List[tuple], divisor: List[int]):
        # 到达了边界
        if u == n:
            divisor.append(p)
            return
        for i in range(factor[u][0] + 1):
            self.dfs(u + 1, n, p, factor, divisor)
            p *= factor[u][1]

    def process(self):
        N = 50010
        self.count = 0
        primes, st = [0] * N, [0] * N
        self.init(N, primes, st)
        # n组测试数据
        n = int(input())
        for i in range(n):
            a, b, c, d = map(int, input().split())
            t, j = d, 0
            factor = list()
            while primes[j] * primes[j] <= t:
                p, s = primes[j], 0
                if t % p == 0:
                    while t % p == 0:
                        s += 1
                        t //= p
                    factor.append((s, p))
                j += 1
            if t > 1:
                factor.append((1, t))
            l = len(factor)
            # 暴力枚举d的所有约数
            divisor = list()
            self.dfs(0, l, 1, factor, divisor)
            res = 0
            for x in divisor:
                # 判断当前的d的约数是否符合两个要求
                if self.gcd(a, x) == b and c * x // self.gcd(c, x) == d:
                    res += 1
            print(res)


if __name__ == '__main__':
    Solution().process()

c++：

#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

typedef long long LL;

const int N = 50010;

int primes[N], cnt;
bool st[N];
struct Factor
{
    int p, s;
}factor[10];
int fcnt;

int dividor[1601], dcnt;

void init(int n)
{
    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;
        }
    }
}

void dfs(int u, int p)
{
    if (u == fcnt)
    {
        dividor[dcnt ++ ] = p;
        return;
    }

    for (int i = 0; i <= factor[u].s; i ++ )
    {
        dfs(u + 1, p);
        p *= factor[u].p;
    }
}

int gcd(int a, int b)
{
    return b ? gcd(b, a % b) : a;
}

int main()
{
    init(N - 1);

    int n;
    cin >> n;
    while (n -- )
    {
        int a, b, c, d;
        cin >> a >> b >> c >> d;

        fcnt = 0;
        int t = d;
        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 ++ ;
                factor[fcnt ++ ] = {p, s};
            }
        }

        if (t > 1) factor[fcnt ++ ] = {t, 1};

        dcnt = 0;
        dfs(0, 1);

        int res = 0;
        for (int i = 0; i < dcnt; i ++ )
        {
            int x = dividor[i];
            if (gcd(a, x) == b && (LL)c * x / gcd(c, x) == d) res ++ ;
        }

        cout << res << endl;
    }
    return 0;
}