bzoj 4537 最小公倍数

给定一张N个顶点M条边的无向图 每条边上带有权值 所有权值都可以分解成2^a*3^b的形式

q个询问，每次询问给定四个参数u、v、a和b，请你求出是否存在一条顶点u到v之间的路径，使得路径依次经过的边上的权值的最小公倍数为2^a*3^b

注意：路径可以不是简单路径

下面是一些可能有用的定义：

最小公倍数：K个数a₁,a₂,…,a_k的最小公倍数是能被每个a_i整除的最小正整数

路径：路径P:P₁,P₂,…,P_k是顶点序列，满足对于任意1<=i<k，节点P_i和P_i+1之间都有边相连

简单路径：如果路径P:P₁,P₂,…,P_k中，对于任意1<=s≠t<=k都有Ps≠Pt，那么称路径为简单路径

思路：

对于每个询问(u,v,A,B)，将a<=A和b<=B的边全部加入并查集中，最后判断u和v是否在同一连通分量中且连通分量包含的最大的a=A，最大的b=B即可

把询问和边离线按a排序，询问时在已经加入的边中按b值排序加入并查集中

结合起来，按a值将询问和边分块，前面的边按第二种做法做，块内的边按第一种做法做就行了

因为并查集需要支持撤销，所以要用按秩合并

 #include<iostream>
 #include<cstdio>
 #include<cmath>
 #include<cstdlib>
 #include<cstring>
 #include<algorithm>
 #include<vector>
 #include<queue>
 #define inf 2139062143
 #define ll long long
 #define MAXN 100100
 using namespace std;
 inline int read()
 {
     int x=,f=;char ch=getchar();
     while(!isdigit(ch)) {if(ch=='-') f=-;ch=getchar();}
     while(isdigit(ch)) {x=x*+ch-'';ch=getchar();}
     return x*f;
 }
 int n,m,T,fa[MAXN],rnk[MAXN],f,pos,b,mxp[MAXN],mxq[MAXN],top,cnt,size,ans[MAXN];
 struct data
 {
     int u,v,p,q,pos;
     bool operator < (const data & a) const {return q<a.q||(q==a.q&&pos<a.pos);}
 }qs[MAXN],e[MAXN<<],tmp[MAXN<<];
 struct stck{int u,v,rnk,p,q;}st[MAXN<<];
 int find(int x) {return x==fa[x]?x:find(fa[x]);}
 void merge(int u,int v,int p,int q)
 {
     int x=find(u),y=find(v);
     if(rnk[x]<rnk[y]) swap(x,y);
     st[++top]=(stck) {x,y,rnk[x],mxp[x],mxq[x]};
     fa[y]=x;
     mxp[x]=max(p,max(mxp[y],mxp[x]));
     mxq[x]=max(q,max(mxq[x],mxq[y]));
     if(rnk[x]==rnk[y]) rnk[x]++;
 }
 bool Cmp(data a,data b) {return a.p<b.p||(a.p==b.p&&a.q<b.q);}
 void dlt()
 {
     fa[st[top].v]=st[top].v,rnk[st[top].u]=st[top].rnk,mxp[st[top].u]=st[top].p,mxq[st[top].u]=st[top].q,top--;
 }
 int main()
 {
     //freopen("al.in","r",stdin);
     //freopen("al.out","w",stdout);
     n=read(),m=read();int x,y,tot=;
     for(int i=;i<=m;i++)
         e[i].u=read(),e[i].v=read(),e[i].p=read(),e[i].q=read(),e[i].pos=;
     size=sqrt(m*);
     sort(e+,e+m+,Cmp);
     T=read();
     for(int i=;i<=T;i++)
         qs[i].u=read(),qs[i].v=read(),qs[i].p=read(),qs[i].q=read(),qs[i].pos=i;
     sort(qs+,qs+T+,Cmp);
     for(int i=;i<=m;i++)
     {
         if((++tot==size)||i==m)
         {
             cnt=;
             for(int j=;j<=i-tot;j++) tmp[++cnt]=e[j];
             for(int j=;j<=T;j++)
                 if(qs[j].p>=e[i-cnt+].p&&(i==m||qs[j].p<e[i+].p)) tmp[++cnt]=qs[j];
             if(i-tot!=cnt)
             {
                 for(int j=;j<=n;j++) fa[j]=j,rnk[j]=,mxp[j]=mxq[j]=-;
                 sort(tmp+,tmp+cnt+);top=;
                 for(int j=;j<=cnt;j++)
                 {
                     if(tmp[j].pos)
                     {
                         for(int k=i-tot+;k<=i+;k++)
                         {
                             if(e[k].p>tmp[j].p||k>i)
                             {
                                 int x=find(tmp[j].u),y=find(tmp[j].v);
                                 if(x==y&&mxp[x]==tmp[j].p&&mxq[x]==tmp[j].q) ans[tmp[j].pos]=;
                                 for(int l=i-tot+;l<=k-;l++) if(e[l].q<=tmp[j].q) dlt();
                                 break;
                             }
                             if(e[k].q<=tmp[j].q) merge(e[k].u,e[k].v,e[k].p,e[k].q);
                         }
                     }
                     else merge(tmp[j].u,tmp[j].v,tmp[j].p,tmp[j].q);
                 }
             }
             tot=;
         }
     }
     for(int i=;i<=T;i++)
         puts(ans[i]?"Yes":"No");
 }