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

题目大意:
给定一个nnn个点,mmm条边无向图。一个四元组(u,v,a,b)(u,v,a,b)(u,v,a,b)代表一条从uuuvvv的属性为(a,b)(a,b)(a,b)无向边。
qqq组询问,一个四元组(u,v,A,B)(u,v,A,B)(u,v,A,B)代表询问是否存在一条uuuvvv的路径(不一定要是简单路径),使得max(a)=Amax(a)=Amax(a)=Amax(a)=Bmax(a)=Bmax(a)=B
n,q≤5∗104,m≤105,a,b≤109n,q≤5*10^4,m≤10^5,a,b≤10^9n,q5104,m105,a,b109

分析:
显然对于每一个询问,只有a≤Aa≤AaAb≤Bb≤BbB的边有用。

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

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

代码:

// 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");
    }
}
要使用并查集来维护前缀和,你可以按照以下步骤进行操作: 1. 首先,需要定义一个并查集的数据结构,包括父节点数组fa和值数组val。其中,fa[i]代表节点i的父节点,val[i]代表节点i与其父节点的差值。 2. 初始化并查集,将每个节点的父节点设置为自身,差值设置为0。 3. 遍历每一个需要进行操作的元素。对于每一个元素,将其与其父节点的差值与当前节点的值相加,得到新的节点值。 4. 如果当前节点与父节点的差值与新的节点值不相等,则说明存在不满足前缀和关系的情况,将变量o设置为false。 5. 如果当前节点与父节点的差值与新的节点值相等,则更新当前节点的父节点为新的父节点,更新当前节点的差值为新的差值。 6. 最后,根据变量o的值判断是否存在不满足前缀和关系的情况。如果o为true,则输出"true",否则输出"false"。 以下是使用并查集维护前缀和的示例代码: ```cpp #include <cstdio> #include <algorithm> #include <cstring> using namespace std; int fa += val = k; } int main() { int T; scanf("%d", &T); int s, t, v; while(T--) { scanf("%d%d", &n, &m); for (int i = 0; i <= n + 1; i++) fa[i = i; memset(val, 0, sizeof(val)); bool o = true; for (int i = 1; i <= m; i++) { scanf("%d%d%d", &s, &t, &v); int fs = find(s - 1), ft = find(t); if (fs == ft) { if (val[s - 1 - val[t != v) o = false; } if (fs != ft) { fa = ft; val = val[t - val[s - 1 + v; } } if (o) printf("true\n"); else printf("false\n"); } return 0; } ``` 在上述代码中,使用并查集来维护前缀和的过程是在find函数中进行的。在查找节点的同时,更新节点的值,实现了维护前缀和的功能。在遍历每个元素之后,根据o的值输出最终的结果。 请注意,上述代码是一个示例,具体的实现可能因问题的要求和代码的细节而有所不同。因此,在实际应用中,你可能需要根据具体情况进行相应的调整。<span class="em">1</span><span class="em">2</span> #### 引用[.reference_title] - *1* [java8集合源码分析-Happy-With-Data-Structure:学习数据结构的一些代码,包括数组,链表,二分搜索...并查集,](https://download.youkuaiyun.com/download/weixin_38661100/19390436)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] - *2* [[HNOI2005]狡猾的商人(并查集维护前缀和)](https://blog.youkuaiyun.com/zhhx2001/article/details/51810163)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值