hdu-1695 容斥原理+欧拉函数

http://acm.hdu.edu.cn/showproblem.php?pid=1695

GCD

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

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.

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).
   
   
  
  

题意：给出两个区间，在两个区间内分别取出一个数，使得gcd(x,y) = k，求满足条件的x,y的对数，需要注意(1,3)和(3,1)属于一种

由于a=c=1，首先先把所有区间没得数均除以k，这样就转化成了求在两个区间内取出两个满足gcd(x,y) = 1，即这两个数互质，所以把已知区间转换一下，转换成[1,b]和[b+1,d]，其中b=min(b,d)，对于[1,b]，即求区间内个数的欧拉函数之和，对于区间[b+1,d]，要求在[1,b]内找到与其区间内的数互质的数，因此问题转化成为区间（1， d）里面与x互素的数的个数先求出x的所有质因数，因此（1，d）区间里面是x的质因数倍数的数都不会与x互素，因此，只需要求出这些数的个数，减掉就可以了。

如果w是x的素因子，则（1，d）中是w倍数的数共有d/w个。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
#define ll __int64
using namespace std;
const int N = 100100;
ll t[100005][20]; //i的第j个质因数
ll num[100005]; //第i个数质因子的个数
ll pf[100005]; //存欧拉函数值
void f(){ //一遍计算欧拉函数值一遍存下每个数的质因子
    ll i, j, k;
    memset(pf, 0, sizeof(pf));
    memset(num, 0, sizeof(num));
    pf[1] = 1;
    for(i=1; i<100005; i++){
        if(!pf[i]){
            for(j=i; j<100005; j+=i){
                if(!pf[j])
                    pf[j] = j;
                pf[j] = pf[j]/i*(i-1);
                t[j][num[j]++] = i;
            }
        }
    }
}

ll fun(ll ii, ll b, ll i){ //容斥原理 递归
    ll j, k, m;
    ll sum = 0;
    for(j=ii; j<num[i]; j++){
        sum += b/t[i][j]-fun(j+1,b/t[i][j],i);
    }
    return sum;
}
int main(){
    int T;
    ll a, b, c, d, k, x, y, ans;
    ll i, j;
    int cas = 1;
    f();
    cin>>T;
    while(T--){
        scanf("%I64d%I64d%I64d%I64d%I64d",&a,&b,&c,&d,&k);
        if(k==0){
            ans = 0;
            printf("Case %d: %I64d\n",cas++, ans);
            continue;
        }
        x = b/k;
        y = d/k;
        b = min(x,y);
        d = max(x,y);
        ans = 0;
        for(i=1; i<=b; i++)
            ans += pf[i];
 //       printf("+++%d\n",ans);
        for(i=b+1; i<=d; i++){
            ans += (b-fun(0,b,i));
        }
        printf("Case %d: %I64d\n",cas++, ans);
    }
    return 0;
}