Hankson的趣味题

# 题意

t组数据，每组数据包含：

给定a,b,c,d,求x的个数，x满足gcd(a,x)=b , lcm(c,x)=d

t ∈ [1,2000]

a,b,c,d ∈ [1 , 2e9]

# 题解

d的约数上界是√d , 但是1～d中平均每个数的约数个数大约只有log d，即约数个数通常远远达不到上界，

2³¹-1内的数字约数个数不超过1600。

因为lcm(c,x)=d，所以x一定是d的约数，枚举所有d的约数，判断满不满足以上两个条件，

这样的复杂度是O(t * √d *log d)

约数是由质因子构成的用质因子的组合求所有约数时间复杂度

就是O(√d)预处理所有质数，然后O(t*1600*log d)

总的复杂度为O(√d+t*1600*log d)

因为组合最多有1600暴力搜索即可，

两个状态当前枚举的质因子，枚举到的约数

#include<bits/stdc++.h>
#define ll long long
#define pii pair<int,int>
#define prime first
#define count second
using namespace std;
const int N=5e5+10;
int primes[N],cnt;
bool st[N];
int dcnt,fcnt;
pii factor[1600];
int divide[N];
void get_primes(int n){
    for(int i=2;i<=n;i++){
        if(!st[i]) primes[cnt++]=i;
        for(int j=0;primes[j]<=n/i;j++){
            st[primes[j]*i]=1;
            if(i%primes[j]==0) break;
        }
    }
}
int gcd(int a,int b){return b?gcd(b,a%b):a;}
void dfs(int u,int p){
    if(u == fcnt){//从0开始，越界了
        divide[dcnt++]=p;
        return;
    }
    for(int i=0;i<=factor[u].count;i++){
        dfs(u+1,p);
        p *= factor[u].prime;
    }
}
int main(){
    get_primes(N-1);
    int t;
    cin>>t;
    while(t--){
        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 sum = 0;
                while (t % p == 0) {
                    sum++;
                    t /= p;
                }
                factor[fcnt++] = {p, sum};
            }
        }
        if(t > 1) factor[fcnt++]={t,1};

        dcnt=0;
        dfs(0,1);
        int ans=0;
        for(int i=0;i<dcnt;i++){
            int x=divide[i];
            if(gcd(a,x)==b && (ll)c*x/gcd(c,x)==d)
                ans++;
        }
        cout<<ans<<endl;
    }
    return 0;
}