洛谷 P3247 [HNOI2016]最小公倍数 分块+并查集

题目大意：
给定一个$n$个点，$m$条边无向图。一个四元组$(u,v,a,b)$代表一条从$u$到$v$的属性为$(a,b)$无向边。
有$q$组询问，一个四元组$(u,v,A,B)$代表询问是否存在一条$u$到$v$的路径（不一定要是简单路径），使得$max(a)=A$，$max(a)=B$。
$n,q\le 5\ast 10^4,m\le 10^5,a,b\le 10^9$

分析：
显然对于每一个询问，只有$a\le A$，$b\le B$的边有用。

可以使用并查集进行维护求解。具体的，如果$u$与$v$在同一集合，直接看$a$,$b$是否可以更新集合的两个最大值。
显然只要连通，必定存在一条路径经过$a$最大的边和$b$最大的边。
如果不连通，那么连上后一样处理。

考虑对$a$值域分块，这里要使用离散化，具体是先对第一维排序，然后对下标分块。
然后对于每一块我们处理第一维在$[a[i],a[i+size])$范围内的询问，其中$i$是某块左边界。
把这些询问按$b$排序，这里的处理有点类似于莫队。
显然$a[1]$~$a[i-1]$的边都是第一维满足的，直接对第二维排序，以为$b$也是有序的，可以使用指针进行插入。
然后枚举$a[i]$~$a[i+size-1]$的边，这些边只有$\sqrt{m}$条，直接暴力处理，然后撤回这些操作。只需要记录每次操作改变的东西，使用启发式合并即可。
这里有点类似于回滚处理，先把右边界移动到询问边界，把左边界设置在块的最右端，再进行左边界移动，完成询问后左边界恢复，右边界不变。这样保证每次操作都是合并操作，撤回操作也是按插入顺序依次撤回。

代码：

// luogu-judger-enable-o2
#include <iostream>
#include <cstdio>
#include <cmath>
#include <algorithm>

const int maxn=1e5+7;

using namespace std;

int n,m,T,la,ra,lb,rb,A,B,cnt,top,block;
int ans[maxn];

struct data{
    int u,v,a,b,num;
}a[maxn],c[maxn],q[maxn],h[maxn];

struct node{
    int fa,size,maxa,maxb;
}p[maxn];

bool cmpa(data a,data b)
{
    return a.a<b.a;
}

bool cmpb(data a,data b)
{
    return a.b<b.b;
}

int find(int x)
{
    if (!p[x].fa) return x;
    return find(p[x].fa);
}

void uni(int u,int v,int a,int b)
{
    u=find(u),v=find(v);
    if (p[u].size>p[v].size) swap(u,v);
    h[++top]=(data){u,v,p[v].maxa,p[v].maxb};
    if (u==v)
    {
        p[v].maxa=max(p[v].maxa,a);
        p[v].maxb=max(p[v].maxb,b);
        return;
    }
    p[u].fa=v;
    p[v].size+=p[u].size;
    p[v].maxa=max(max(p[v].maxa,a),p[u].maxa);
    p[v].maxb=max(max(p[v].maxb,b),p[u].maxb);
}

void del(int num)
{
    int u=h[num].u,v=h[num].v,a=h[num].a,b=h[num].b;
    if (u==v)
    {
        p[v].maxa=a;
        p[v].maxb=b;
        return;
    }
    else
    {
        p[u].fa=0;
        p[v].size-=p[u].size;
        p[v].maxa=a;
        p[v].maxb=b;
    }
}

int main()
{
    scanf("%d%d",&n,&m);
    for (int i=1;i<=m;i++)
    {
        scanf("%d%d%d%d",&a[i].u,&a[i].v,&a[i].a,&a[i].b);
    }
    sort(a+1,a+m+1,cmpa);
    scanf("%d",&T);
    for (int i=1;i<=T;i++)
    {
        scanf("%d%d%d%d",&q[i].u,&q[i].v,&q[i].a,&q[i].b);
        q[i].num=i;
    }	
    sort(q+1,q+T+1,cmpb);
    block=trunc(sqrt(m))+1;
    for (int i=1;i<=m;i+=block)
    {
        cnt=0;
        for (int j=1;j<=T;j++)
        {
            if ((q[j].a>=a[i].a) && ((i+block>m) || (q[j].a<a[i+block].a)))
            {
                c[++cnt]=q[j];
            }
        }
        sort(a+1,a+i,cmpb);
        for (int j=1;j<=n;j++) p[j]=(node){0,1,-1,-1};
        int now=1;
        for (int j=1;j<=cnt;j++)
        {
            while ((now<i) && (a[now].b<=c[j].b))
            {
                uni(a[now].u,a[now].v,a[now].a,a[now].b);
                now++;
            }
            top=0;
            for (int k=i;(k<=m) && (k<i+block);k++)
            {
                if ((a[k].a<=c[j].a) && (a[k].b<=c[j].b))
                {
                	uni(a[k].u,a[k].v,a[k].a,a[k].b);
                }
            }
            int cu=find(c[j].u),cv=find(c[j].v);
            ans[c[j].num]=((cu==cv) && (p[cu].maxa==c[j].a) && (p[cu].maxb==c[j].b));
            while (top)
            {
            	del(top);
            	top--;
            }
        }
    }
    for (int i=1;i<=T;i++)
    {
        if (ans[i]) printf("Yes\n");
               else printf("No\n");
    }
}