[HNOI2016] 最小公倍数

P4053 [Hnoi2016 day1]最小公倍数

时间限制 : - MS   空间限制 : 565536 KB  评测说明 : 4s

问题描述

给定一张N个顶点M条边的无向图(顶点编号为1,2,…,n)，每条边上带有权值。所有权值都可以分解成2^a*3^b
的形式。现在有q个询问，每次询问给定四个参数u、v、a和b，请你求出是否存在一条顶点u到v之间的路径，使得
路径依次经过的边上的权值的最小公倍数为2^a*3^b。注意：路径可以不是简单路径。下面是一些可能有用的定义
：最小公倍数：K个数a1,a2,…,ak的最小公倍数是能被每个ai整除的最小正整数。路径：路径P:P1,P2,…,Pk是顶
点序列，满足对于任意1<=i<k，节点Pi和Pi+1之间都有边相连。简单路径：如果路径P:P1,P2,…,Pk中，对于任意1
<=s≠t<=k都有Ps≠Pt，那么称路径为简单路径。

输入格式

第一行包含两个整数N和M，分别代表图的顶点数和边数。接下来M行，每行包含四个整数u、v、a、
b代表一条顶点u和v之间、权值为2^a*3^b的边。接下来一行包含一个整数q，代表询问数。接下来q行，每行包含四
个整数u、v、a和b，代表一次询问。询问内容请参见问题描述。1<=n,q<=50000、1<=m<=100000、0<=a,b<=10^9

输出格式

对于每次询问，如果存在满足条件的路径，则输出一行Yes，否则输出一行 No（注意：第一个字母大写，其余
字母小写） 。

样例输入

4 5 
1 2 1 3 
1 3 1 2 
1 4 2 1 
2 4 3 2 
3 4 2 2 
5 
1 4 3 3 
4 2 2 3 
1 3 2 2 
2 3 2 2 
1 3 4 4 

样例输出

Yes 
Yes 
Yes 
No 
No 

提示

样例说明:

分析：首先不难发现所谓的lcm就是路径上a的最大值和b的最大值，那么暴力方法就出来了，选出所有a不大于q.a并且b不大于q.b的边，跑带权并查集，暴力验证。

不bb，说正解。

先把m条边按a排序并分块，q次询问按b排序。

对于每一块，我们只处理a在此块的边的a的范围内的询问，把这些询先弄出来。

此时，我们再把之前的块的边按b排序。

由于这些询问的a一定大于前面块的边的a，即前面的块中的边的a一定满足限制，只需满足b。

并查集，要回退，回退的操作是哪些呢？一个询问在这个块内满足条件的边。之前块的边是不需要回退的，因为a满足，询问的b递增，所以之前加进来的边后面的询问一定可以用！

详细见代码吧，还是比较好懂。

#include<cstdio>  
#include<iostream>  
#include<cstdlib>  
#include<algorithm>  
#include<cstring>  
#include<queue>  
#include<stack>  
#include<vector> 
#include<cmath>  
#define ll long long
using namespace std;
const int inf=0x3f3f3f3f;
template <typename T>  
inline void _read(T& x){  
    char t=getchar();bool sign=true;  
    while(t<'0'||t>'9'){if(t=='-')sign=false;t=getchar();}  
    for(x=0;t>='0'&&t<='9';t=getchar())x=x*10+t-'0';  
    if(!sign)x=-x;  
}
int n,m,q,e;
int block;
int top;
int tot;
struct node{
	int x,y,a,b,id;
	node(){}
	node(int X,int Y,int A,int B,int ID){x=X;y=Y;a=A;b=B;id=ID;}
};
bool cmp1(node A,node B){
	if(A.a==B.a)return A.b<B.b;
	else return A.a<B.a;
}
bool cmp2(node A,node B){
	if(A.b==B.b)return A.a<B.a;
	else return A.b<B.b;
}
node edge[100005];
node work[100005];
int need[100005];
int fa[100005],maxa[100005],maxb[100005],size[100005];
bool ans[100005];
struct back{
	int x,y,fa,ma,mb,si;
	back(){}
	back(int X,int Y,int FA,int MA,int MB,int SI){x=X;y=Y;fa=FA;ma=MA;mb=MB;si=SI;}
};
back roll[100005];
int getfather(int x){
	if(fa[x]!=x)return getfather(fa[x]);
	else return x;
}
void merge(int x,int y,int a,int b){
	int fx=getfather(x),fy=getfather(y);
	if(size[fx]>size[fy])swap(fx,fy);
	roll[++top]=back(fx,fy,fa[fx],maxa[fy],maxb[fy],size[fy]);
	if(fx==fy){
		maxa[fx]=max(maxa[fx],a);
		maxb[fx]=max(maxb[fx],b);
		return;
	}
	fa[fx]=fy;
	size[fy]+=size[fx];
	maxa[fy]=max(maxa[fy],max(a,maxa[fx]));
	maxb[fy]=max(maxb[fy],max(b,maxb[fx]));
}
void rollback(){
	int i;
	for(i=top;i;i--){
		fa[roll[i].x]=roll[i].fa;
		maxa[roll[i].y]=roll[i].ma;
		maxb[roll[i].y]=roll[i].mb;
		size[roll[i].y]=roll[i].si;
	}
	top=0;
}
int main(){
	int i,j,k;
	cin>>n>>m;
	for(i=1;i<=m;i++){
		_read(edge[i].x);_read(edge[i].y);_read(edge[i].a);_read(edge[i].b);
	}
	cin>>q;
	for(i=1;i<=q;i++){
		_read(work[i].x);_read(work[i].y);_read(work[i].a);_read(work[i].b);
		work[i].id=i;
	}
	sort(edge+1,edge+1+m,cmp1);
	sort(work+1,work+1+q,cmp2);
	block=755;
	for(i=1;i<=m;i+=block){
		tot=top=0;
		for(j=1;j<=q;j++){
			if(work[j].a>=edge[i].a&&(i+block>m||work[j].a<edge[i+block].a)){
				need[++tot]=j;
			}
		}
		sort(edge+1,edge+i,cmp2);
		for(j=1;j<=n;j++){
			fa[j]=j;maxa[j]=-1;maxb[j]=-1;size[j]=1;
		}
		int pos=1;
		for(j=1;j<=tot;j++){
			while(pos<i&&work[need[j]].b>=edge[pos].b)merge(edge[pos].x,edge[pos].y,edge[pos].a,edge[pos].b),pos++;
			top=0;
			for(k=i;k<i+block&&k<=m;k++){
				if(edge[k].a<=work[need[j]].a&&edge[k].b<=work[need[j]].b)merge(edge[k].x,edge[k].y,edge[k].a,edge[k].b);
			}
			int x,y;
			x=getfather(work[need[j]].x);y=getfather(work[need[j]].y);
			if(x==y&&maxa[x]==work[need[j]].a&&maxb[x]==work[need[j]].b)ans[work[need[j]].id]=true;
			else ans[work[need[j]].id]=false;
			rollback();
		}
	}
	for(i=1;i<=q;i++){
		if(ans[i])puts("Yes");
		else puts("No");
	}
}