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

最新推荐文章于 2022-04-13 21:37:45 发布

Amber_lylovely

最新推荐文章于 2022-04-13 21:37:45 发布

阅读量220

点赞数

分类专栏：分块并查集

本文链接：https://blog.csdn.net/liangzihao1/article/details/88632317

版权

并查集同时被 2 个专栏收录

21 篇文章 0 订阅

订阅专栏

分块

10 篇文章 1 订阅

订阅专栏

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

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

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

考虑对 $a$ 值域分块，这里要使用离散化，具体是先对第一维排序，然后对下标分块。
然后对于每一块我们处理第一维在 $[a [i], a [i + s i z e])$ 范围内的询问，其中 $i$ 是某块左边界。
把这些询问按 $b$ 排序，这里的处理有点类似于莫队。
显然 $a [1]$ ~ $a [i - 1]$ 的边都是第一维满足的，直接对第二维排序，以为 $b$ 也是有序的，可以使用指针进行插入。
然后枚举 $a [i]$ ~ $a [i + s i z e - 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");
    }
}