hdu 1695 GCD 欧拉方程 容斥理论

GCD(跃越)

Time Limit: 6000/3000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 2596    Accepted Submission(s): 938

Problem Description

Given 5 integers: a, b, c, d, k, you're to find x in a...b, y in c...d that GCD(x, y) = k. GCD(x, y) means the greatest common divisor of x and y. Since the number of choices may be very large, you're only required to output the total number of different number pairs.
Please notice that, (x=5, y=7) and (x=7, y=5) are considered to be the same.
就是给你5个整数，写出x,y between(a,b) (c,d) 满足 GCD (x,y) = k
Yoiu can assume that a = c = 1 in all test cases.

 

Input

The input consists of several test cases. The first line of the input is the number of the cases. There are no more than 3,000 cases.
Each case contains five integers: a, b, c, d, k, 0 < a <= b <= 100,000, 0 < c <= d <= 100,000, 0 <= k <= 100,000, as described above.

 

Output

For each test case, print the number of choices. Use the format in the example.

 

Sample Input

  
  

   
   2
1 3 1 5 1
1 11014 1 14409 9
  
  

 

Sample Output

  
  

   
   Case 1: 9
Case 2: 736427


   
   

    
    

     
     Hint
    
    
For the first sample input, all the 9 pairs of numbers are (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 3), (2, 5), (3, 4), (3, 5).
   
   
   
    
  
  

容斥道理的具体如下：

          区间中与i不互质的个数 = （区间中i的每个质因数的倍数个数）-（区间中i的每两个质因数乘积的倍数）+（区间中i的每3个质因数的成绩的倍数个数）-（区间中i的每4个质因数的乘积）+...

欧拉函数的编程实现

　　利用欧拉函数和它本身不同质因数的关系，用筛法计算出某个范围内所有数的欧拉函数值。

　　欧拉函数和它本身不同质因数的关系：欧拉函数ψ（N）=N{∏p|N}（1－1/p）。（P是数N的质因数）

　　如：

　　ψ（10）=10×（1－1/2）×（1－1/5）=4；

　　ψ（30）=30×（1－1/2）×（1－1/3）×（1－1/5）=8；

　　ψ（49）=49×（1－1/7）=42。

通式：φ(x)=x(1-1/p1)(1-1/p2)(1-1/p3)(1-1/p4)…..(1-1/pn),其中p1, p2……pn为x的所有质因数，x是不为0的整数。

#include<iostream>
using namespace std;
const int Max=100005;
__int64 elur[Max];//存放每个数的欧拉函数值
int num[Max];//存放数的素因子个数
int p[Max][20];//存放数的素因子
void init()//筛选法得到数的素因子及每个数的欧拉函数值
{
    elur[1]=1;
    for(int i=2;i<Max;i++)
    {
        if(!elur[i])
        {
            for(int j=i;j<Max;j+=i)
            {
                if(!elur[j])
                    elur[j]=j;
                elur[j]=elur[j]*(i-1)/i;
                p[j][num[j]++]=i;
            }
        }
        elur[i]+=elur[i-1]; //进行累加（法里数列长度）
    }
}
int dfs(int idx,int b,int now)//求不大于b的数中,与now不互质的数的个数;
{                                //dfs()写的容斥原理
    int ans=0;
    for(int i=idx;i<num[now];i++)//容斥原理来求A1并A2并A3.....并Ak的元素的数的个数.
        ans += b/p[now][i]-dfs(i+1,b/p[now][i],now);
    return ans;
}

int main()
{
    int t,a,b,c,d,k;
    init();
    scanf("%d",&t);
    for(int ca=1;ca<=t;ca++)
    {
        scanf("%d%d%d%d%d",&a,&b,&c,&d,&k);
        printf("Case %d: ",ca);
        if(k==0)
        {
            printf("0\n");
            continue;
        }
        if(b>d)
            swap(b,d);
        b/=k;  d/=k;
        __int64 ans=elur[b];
        for(int i=b+1;i<=d;i++)
            ans+=b-dfs(0,b,i);//求不大于b的数中,与i不互质的数的个数
        printf("%I64d\n",ans);
    }
    return 0;
}