GCD and LCM HDU - 4497(容斥 & 唯一分解)

Given two positive integers G and L, could you tell me how many solutions of (x, y, z) there are, satisfying that gcd(x, y, z) = G and lcm(x, y, z) = L?
Note, gcd(x, y, z) means the greatest common divisor of x, y and z, while lcm(x, y, z) means the least common multiple of x, y and z.
Note 2, (1, 2, 3) and (1, 3, 2) are two different solutions.
Input
First line comes an integer T (T <= 12), telling the number of test cases.
The next T lines, each contains two positive 32-bit signed integers, G and L.
It’s guaranteed that each answer will fit in a 32-bit signed integer.
Output
For each test case, print one line with the number of solutions satisfying the conditions above.
Sample Input
2
6 72
7 33

Sample Output
72
0
题目链接
给定三个数的gcd和lcm，求可能的三个数的组合有多少种。这个需要用唯一分解定理，每一个数都能分成若干个素数的幂的乘积的形式。
三个数分解完之后，gcd是取每个素数的最小次幂的乘积，lcm是取每个素数的最大次幂乘积，这样如果gcd中分解出来的素数lcm一定有，如果没有，那么就是错误的，直接输出0。否则，假设同一个素数，在gcd中和lcm中的幂分别是num1和num2，那么这三个数中一定有一个含有最高次幂，一个含有最低次幂，剩下的都可以，这里就用到容斥原理了，也就是：

tmp = (num1-num2+1)(num1-num2+1)(num1-num2+1); //所有的可能结果
tmp -= 2*(num1-num2)(num1-num2)(num1-num2); //减去一个没有num1的情况和没有num2的情况
tmp += (num1-num2-1)(num1-num2-1)(num1-num2-1); //多减了一次num1，num2都没有的情况，再加上

我参考的某位的代码，可能很长，很繁琐，不如别人来的精简，但是我感觉能从里面学到点东西。

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <math.h>
#include <map>
using namespace std;
const int MAXN = 1e6 + 5;
int prime[MAXN], a[100], b[100];   //  prime[0] is used to store the number of prime
int fatCnt;
long long factor[100][2];
map<int, int> mp1, mp2; //对应项指数

void getPrime()
{
    memset(prime, 0, sizeof(prime));
    for(int i = 2; i <= MAXN; i++)
    {
        if(!prime[i])   prime[++prime[0]] = i;
        for(int j = 1; j <= prime[0] && prime[j] <= MAXN / i; j++)
        {
            prime[prime[j] * i] = 1;
            if(i % prime[j] == 0)   break;  //如果这个乘数是这个素数的倍数，那么就可以直接退出了，因为这在之前已经遍历过了
        }
    }
}

int getFactors(long long x)
{
    fatCnt = 0;
    long long tmp = x;
    for(int i = 1; prime[i] <= tmp / prime[i]; i++)
    {
        factor[fatCnt][1] = 0;
        if(tmp % prime[i] == 0)
        {
            factor[fatCnt][0] = prime[i];
            while(tmp % prime[i] == 0)
            {
                factor[fatCnt][1] ++;
                tmp /= prime[i];
            }
            fatCnt++;
        }
    }
    if(tmp != 1)
    {
        factor[fatCnt][0] = tmp;
        factor[fatCnt++][1] = 1;
    }
    return fatCnt;
}

int main()
{
    getPrime(); //初始化素数
    int n, m;
    int T;
    scanf("%d", &T);
    while(T--)
    {
        scanf("%d%d", &n, &m);
        mp1.clear();
        mp2.clear();
        getFactors(m);
        int cnt1 = fatCnt;
        for(int i = 0; i < cnt1; i++)
        {
            mp1[factor[i][0]] = factor[i][1];
            a[i] = factor[i][0];
        }
        getFactors(n);
        int cnt2 = fatCnt;
        bool flag = true;
        for(int i = 0;i < cnt2;i++)
        {
            mp2[factor[i][0]] = factor[i][1];
            if(mp1[factor[i][0]] < factor[i][1])    //只要有lcm里面的因子比gcd里面的还小，那么一定是不对的
                flag = false;
            b[i] = factor[i][0];
            //printf("%I64d %I64d\n",factor[i][0],factor[i][1]);
        }
        if(!flag)
        {
            printf("0\n");
            continue;
        }
        int ans = 1;
        for(int i = 0; i < cnt1; i++)
        {
            int num1 = mp1[a[i]];
            int num2 = mp2[a[i]];
            if(num1 == num2)
                ans *= 1;
            else
            {
                //3个数p的指数必须在num1~num2之间，而且必须有一个为num1,一个为num2
                long long tmp = (num1-num2+1)*(num1-num2+1)*(num1-num2+1);  //所有的可能结果
                tmp -= 2*(num1-num2)*(num1-num2)*(num1-num2);   //减去一个没有num1的情况和没有num2的情况
                tmp += (num1-num2-1)*(num1-num2-1)*(num1-num2-1);   //多减了一次num1，num2都没有的情况，再加上
                ans *= tmp;
            }
        }
        printf("%d\n",ans);
    }
    return 0;
}