hdu_4497GCD and LCM(合数分解)

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=4497

GCD and LCM

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65535/65535 K (Java/Others)
Total Submission(s): 2151    Accepted Submission(s): 955

Problem Description

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

 

Source

2013 ACM-ICPC吉林通化全国邀请赛——题目重现

题意：给出三个数的最大公约数和最小公倍数，让求abc这三个数可能的情况，注意ABC的位置不同算不同的情况

考虑先分解最小公倍数。合数分解后，再分解最大公约数，可知，如果最大公约数中有最小公倍数中没有的质因数因子的话，那么答案肯定为0

然后考虑每一个因子pi有设合数分解最小公倍数的个数为bi合数分解最大公约数的个数为bi

下面有两种考虑方法

　　排列组合：易得三个数中的对于pi的情况必须有一个个数是bi，另一个是ai，然后就可以先选出两个位置一个bi一个ai然后最后一个位置上的个数一定介于ai和bi之间即（bi-ai-1）种情况。

所以最后的公式为ans *=  A(3,2)*(bi-ai-1) = 6*(bi-ai-1) ;

注意，如果先筛素数的时候筛到1^6 然后如果L除以最后一个素数的时候不等于1，那么说明它（L的最后一个因子）一定是大于10^6的一个素数，因为10^12 = 10^6^2 > x^2>y;如果y存在一个非素数的因子k的话，有k*t = y 且k>x,则t<x则t已经被筛掉了。所以剩下的因子一定是素因子。一开始没有考虑这种特殊情况wa掉了。。。

注意，还要注意只有当(bi-ai-1) 有意义的时候才可以计算，因为如果bi==ai的时候可以发现正确结果是对于这一位应该是只用一种情况，就是三个数都相等，所以要特判一下。。。。后来又因为这个wa了一次~~~~(>_<)~~~~

　　容斥定理：同样是考虑每个因子，有所有的情况是每个位置都可以取（bi-ai+1）种情况即(bi-ai+1)^3，要减去没有bi个因子的情况和没有ai个因子的情况即2*(bi-ai)^3

然后发现减多了，要加上同时没有因子ai和bi的情况即(bi-ai-1)^3

这里同样要注意上面的注意。

 //合数分解
 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 using namespace std;
 #define ll long long
 const int maxn = ;
 int prime[maxn];
 bool pri[maxn];
 int cnt;
 void init()
 {
     cnt = ;
     pri[] = pri[] = ;
     //prime[0] = 2;
     for(int i = ; i < maxn; i++){
         if(!pri[i]){

             prime[cnt++] = i;
             for(int j = i+i; j < maxn; j+=i)
             {
                 pri[j]=;
             }
         }
     }
     return;
 }
 ll m1[],m2[];
 ll c1[],c2[];
 int main()
 {
     init();
     int T;
     ll G,L;
     scanf("%d",&T);
     while(T--)
     {
         memset(m1,,sizeof(m1));
         memset(c1,,sizeof(c1));
         memset(m2,,sizeof(m2));
         memset(c2,,sizeof(c2));
         scanf("%lld%lld",&G,&L);
         int tm = ;
         bool in = ;
         bool fl = ;
         //printf("%d\n",prime[1]);
         if(L%G) fl = ;
         for(int i = ; i< cnt; i++){
             while(prime[i]<=L&&L%prime[i]==){
                 L = L/prime[i];
                 m2[tm] = prime[i];
                 c2[tm]++;
                 in = ;
             }
             if(in) tm++;
             in = ;
         }
         if(L!=){
             m2[tm] = L;
             c2[tm] = ;
             tm++;
         }
         for(int i = ; i < tm; i++){
             while(m2[i]<=G&&G%m2[i]==){
                 G = G/m2[i];
                 m1[i] = m2[i];
                 c1[i]++;
             }
             in = ;
         }
         if(G!=){
            fl = ;
         }
         /*puts("haha");
         for(int i = 0; i < tm; i++){
             printf("m1[%d]=%d; m2[%d]=%d;\n",i,m1[i],i,m2[i]);
             printf("c1[%d]=%d; c2[%d]=%d;\n",i,c1[i],i,c2[i]);
         }
         */
         if(fl==) {puts(""); continue;}
         ll ans = ;
         for(int i = ; i < tm; i++){
             //需要特判当c1[i] =c2[i]的情况
             ll E;
             if(c1[i]==c2[i]) E = ;
             else E = c2[i]-c1[i]-;
             /*
                 也可以用排列组合的想法，每次找到两个数包含首尾的两个值，然后中间的一个在从所有可能中选取一个。
                 这样最后的公式就是A(3,2)*(c2[i]-c1[i]-1);
                 所以
                 if(c2[i]>c1[i]) ans = ans*6*(c2[i]-c1[i]-1);
                     */
             ans = ans*((c2[i]-c1[i]+)*(c2[i]-c1[i]+)*(c2[i]-c1[i]+)-*(c2[i]-c1[i])*(c2[i]-c1[i])*(c2[i]-c1[i])+E*E*E);
         }
         printf("%lld\n",ans);
     }
     return ;
 }