HDU6287 口算训练 【两种优化版分解质因数】【二分下标】

口算训练

Time Limit: 8000/4000 MS (Java/Others)    Memory Limit: 512000/512000 K (Java/Others)
Total Submission(s): 5642    Accepted Submission(s): 1234

 

Problem Description

小Q非常喜欢数学，但是他的口算能力非常弱。因此他找到了小T，给了小T一个长度为n的正整数序列a1,a2,...,an，要求小T抛出m个问题以训练他的口算能力。

每个问题给出三个正整数l,r,d，小Q需要通过口算快速判断al×al+1×...×ar−1×ar是不是d的倍数。

小Q迅速地回答了出来，但是小T并不知道正确答案是什么，请写一个程序帮助小T计算这些问题的正确答案。

 

Input

第一行包含一个正整数T(1≤T≤10)，表示测试数据的组数。

每组数据第一行包含两个正整数n,m(1≤n,m≤100000)，分别表示序列长度以及问题个数。

第二行包含n个正整数a1,a2,...,an(1≤ai≤100000)，表示序列中的每个数。

接下来m行，每行三个正整数l,r,d(1≤l≤r≤n,1≤d≤100000)，表示每个问题。

 

Output

对于每个问题输出一行，若是倍数，输出Yes，否则输出No。

 

Sample Input

1 5 4 6 4 7 2 5 1 2 24 1 3 18 2 5 17 3 5 35

 

Sample Output

Yes No No Yes

 

Source

"字节跳动杯"2018中国大学生程序设计竞赛-女生专场

 

Statistic | Submit | Discuss | Note

如果用传统的分解质因数方法，会超时。
而分解质因数的优化版，要结合素数筛法。

优化版也分为两种版本，首先是第一个版本。 打素数表法

（根据分解质因数的不一样，分为两个版本）

除了本题描述的以外，还有一种比较基础的优化，

就是先做出一个素数表

然后每次分解质因数的时候，直接取出所有素数

不需要枚举所有根号下的数了

所以一共三种优化
 

#include <bits/stdc++.h>
using namespace std;
const int N=1e5+10;
vector<int> g[N]; //g[]的第一维[]下标是质因数，第二维存这个质数在序列里面哪个数的下标
/*
解释g[N] :
如果某个质因数  在序列里下标为1的数里面出现了多次
那就多次存储下标1 （重复存储）


最终某个数的下标被g[p]存储了几次，就代表这个数有多少个p 质因数 
*/ 

int primes[N],cnt;
bool st[N]; 


void init()
{
	for(int i=2;i<N;i++)
	{
		if(!st[i])
		{
			primes[cnt++]=i;
		}
		
		for(int j=0;primes[j]*i<N;j++)
		{
			st[primes[j]*i]=true;
			if(i%primes[j]==0)
			{
				break;
			}
		}
	}
}



void divide(int x,int idx) //对x分解质因数
{
	for(int i=0;st[x];i++)  //只要x是合数，就可以一直取筛选出来的素数 
	{
		int p=primes[i];
		if(x%p==0)
		{
			while(x%p==0)
			{
				x/=p;
				g[p].push_back(idx);  //存下标 
			}
		}
	} 
	
	if(x>1) 
	{
	   int p=x;
	   g[p].push_back(idx); 
    }
}

int main()
{
	init();
	int T;
	scanf("%d",&T);
	
	while(T--)
	{
		for(int i=0;i<N;i++) g[i].clear(); 
		int n,m;
		scanf("%d%d",&n,&m);
		for(int i=1;i<=n;i++)
		{
			int x;
			cin>>x;
			divide(x,i);
		}
		
		while(m--)
		{
			int l,r,d;
			scanf("%d%d%d",&l,&r,&d);
			bool flag=true;
			
			//对d分解质因数 
			int x=d;
		
			for(int i=0;st[x];i++)
			{
			  int p=primes[i];
			  int sum=0;
			  if(x%p==0)
			  {
				while(x%p==0)
				{
					x=x/p;
					sum++;
				} 
			  }
			  int b=upper_bound(g[p].begin(),g[p].end(),r)-g[p].begin(); //比r大的下标
			  int a=lower_bound(g[p].begin(),g[p].end(),l)-g[p].begin(); //大于等于l的下标 
			  
			  if(b-a<sum) //如果质因数数量不够
			  {
			  	flag=false;
			  	break;
			  } 
			}
			
			if(x>1) 
			{
				int p=x;
				int b=upper_bound(g[p].begin(),g[p].end(),r)-g[p].begin(); //比r大的下标
			    int a=lower_bound(g[p].begin(),g[p].end(),l)-g[p].begin(); //大于等于l的下标 
			    if(b-a<1)
			    {
			    	flag=false;
				}
			}
			
			
			if(flag) puts("Yes");
			else puts("No");
			
		}
		
	}
	
	return 0;
}

其次是第二个版本 

/*
优化版本2：
（主要在分解质因数上和第一个版本不一样） 
*/

#include <bits/stdc++.h>
using namespace std;
const int N=1e5+10;
int primes[N],idx;
bool st[N];
int minp[N];

//int a[N];
vector<int> g[N];


void init()
{
	for(int i=2;i<N;i++)
	{
		if(!st[i])
		{
		primes[idx++]=i;
		minp[i]=i;
	    }
		
		for(int j=0;primes[j]*i<N;j++)
		{
			st[primes[j]*i]=true;
			minp[primes[j]*i]=primes[j];
			if(i%primes[j]==0)
			{
				break;
			}
		}
	}
}

void divide(int x,int idx)
{
		while(x>1)
		{
			int p=minp[x];
			while(x%p==0)
			{
				x/=p;
				g[p].push_back(idx);
			}
		}
} 


int main()
{
	init();
	int T;
	scanf("%d",&T);
	while(T--)
	{
		for(int i=0;i<N;i++) g[i].clear();
		int n,m;
		scanf("%d%d",&n,&m);
		for(int i=1;i<=n;i++)
		{
			int x;
		    scanf("%d",&x);
			
			divide(x,i);
	    }
	    
	    while(m--)
	    {
	    	int l,r,d;
	        scanf("%d%d%d",&l,&r,&d);
	    	bool flag=true;
	    	int x=d;
	    	while(x>1)
	    	{
	    		int p=minp[x];
	    		int sum=0;
	    		while(x%p==0)
	    		{
	    			x/=p;
	    			sum++;
				}
				
				int b=upper_bound(g[p].begin(),g[p].end(),r)-g[p].begin();
				int a=lower_bound(g[p].begin(),g[p].end(),l)-g[p].begin();
				
				if(b-a<sum)
				{
				//	cout<<" b is "<<b<<" a is "<<a<<endl;
					flag=false;
					break;
				}
			}
			
			if(flag) puts("Yes");
			else puts("No");
		}
	}
	return 0;
}