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=0,f=1;char ch=getchar();
    while(!isdigit(ch)) {if(ch=='-') f=-1;ch=getchar();}
    while(isdigit(ch)) {x=x*10+ch-'0';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<<1],tmp[MAXN<<2];
struct stck{int u,v,rnk,p,q;}st[MAXN<<1];
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=0;
    for(int i=1;i<=m;i++)
        e[i].u=read(),e[i].v=read(),e[i].p=read(),e[i].q=read(),e[i].pos=0;
    size=sqrt(m*2);
    sort(e+1,e+m+1,Cmp);
    T=read();
    for(int i=1;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+1,qs+T+1,Cmp);
    for(int i=1;i<=m;i++)
    {
        if((++tot==size)||i==m)
        {
            cnt=0;
            for(int j=1;j<=i-tot;j++) tmp[++cnt]=e[j];
            for(int j=1;j<=T;j++)
                if(qs[j].p>=e[i-cnt+1].p&&(i==m||qs[j].p<e[i+1].p)) tmp[++cnt]=qs[j];
            if(i-tot!=cnt)
            {
                for(int j=1;j<=n;j++) fa[j]=j,rnk[j]=0,mxp[j]=mxq[j]=-1;
                sort(tmp+1,tmp+cnt+1);top=0;
                for(int j=1;j<=cnt;j++)
                {
                    if(tmp[j].pos)
                    {
                        for(int k=i-tot+1;k<=i+1;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]=1;
                                for(int l=i-tot+1;l<=k-1;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=0;
        }
    }
    for(int i=1;i<=T;i++)
        puts(ans[i]?"Yes":"No");
}