区间互素(筛法欧拉函数模板+容斥原理)(1695)

GCD

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

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

  
  

原题题意是求[1,b]中的x和[1,d]中的y，满足gcd(x,y)=k的个数。首先很重要的一步就是转化成[1,b/k]中的x和[1,d/k]中的y，满足gcd(x,y)=1的个数，所以原题转化成了两个区间互素二元组的个数。我们可以从大区间(假设[1,d])枚举i，求i在[1,b]区间内与其互素的数的个数，这样的话可以分成两种情况：①当i在区间[1,b]内时，直接欧拉函数得到值(为了提高效率欧拉函数的数组记录累加值，这样可以直接得到euler[b]) ；②当超出区间时，这时就是一个经典的容斥求互素个数的问题了(在计算欧拉函数时就可以把每个数的因子保存在一个数组中，这样方便后面直接使用)。

/*------------------Header Files------------------*/
#include <iostream>
#include <cstring>
#include <string>
#include <cstdio>
#include <algorithm>
#include <cstdlib>
#include <ctype.h>
#include <cmath>
#include <stack>
#include <queue>
#include <deque>
#include <map>
#include <vector>
#include <set>
#include <limits.h>
using namespace std;
/*------------------Definitions-------------------*/
#define LL long long
#define uLL unsigned long long
#define PI acos(-1.0)
#define INF 0x3F3F3F3F
#define MOD 9973
#define MAX 100005
#define lson rt<<1,l,m
#define rson rt<<1|1,m+1,r
/*---------------------Work-----------------------*/
int a,b,c,d,k;
LL ans;
LL euler[MAX]; //不是单纯的某个数的欧拉函数值，是从1到n的累加值
int num[MAX]; //保存当前数的因子个数
int prime[MAX][10]; //保存当前数的因子
void EulerPrime() //筛法的欧拉函数
{
	euler[1]=1; //1和自己互素
	for(int i=2;i<MAX;i++)
	{
		if(!euler[i])
		{
			for(int j=i;j<MAX;j+=i)
			{
				if(!euler[j]) euler[j]=j;
				euler[j]=euler[j]/i*(i-1); //先除后乘，防溢出
				prime[j][num[j]++]=i;
			}
		}
		euler[i]+=euler[i-1]; //不能少这一句，因为是累加值
	}
}
void DFS(int num1,int cur,int cnt,LL temp) //经典的DFS容斥函数
{
	temp*=prime[num1][cur];
	if(cnt&1) ans+=b/temp;
	else ans-=b/temp;
	for(int i=cur+1;i<num[num1];i++)
		DFS(num1,i,cnt+1,temp);
}
void work()
{
	int T;
	EulerPrime();
	/*
	for(int i=1;i<=20;i++)
	{
		printf("%d:euler:%d ",i,euler[i]);
		for(int j=0;j<num[i];j++)
			printf("%d ",prime[i][j]);
		printf("\n");
	}
	*/
	while(scanf("%d",&T)==1)
	{
		for(int Case=1;Case<=T;Case++)
		{
			printf("Case %d: ",Case);
			scanf("%d%d%d%d%d",&a,&b,&c,&d,&k);
			if(k==0) //k还可以为0
			{
				printf("0\n");
				continue;
			}
			if(d<b) swap(b,d);
			b/=k,d/=k;
			LL res=euler[b]; //枚举的i小于b时直接可以得到
			//当i大于b时就要使用容斥原理了
			for(int i=b+1;i<=d;i++)
			{
				ans=0;
				for(int j=0;j<num[i];j++)
					DFS(i,j,1,1);
				res+=b-ans;
			}
			printf("%I64d\n",res);
		}
	}
}
/*------------------Main Function------------------*/
int main()
{
	//freopen("test.txt","r",stdin);
	work();
	return 0;
}