[BZOJ4530][Bjoi2014]大融合（树链剖分+并查集）

最新推荐文章于 2019-01-14 18:37:35 发布
最新推荐文章于 2019-01-14 18:37:35 发布
阅读量1k 收藏
点赞数
分类专栏： 题解 树链剖分 并查集 省选
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Clove_unique/article/details/52657827
版权
题解 同时被 3 个专栏收录
1097 篇文章 4 订阅
订阅专栏
省选
211 篇文章 0 订阅
订阅专栏
并查集
41 篇文章 0 订阅
订阅专栏

题目描述

传送门

题解

显然一条边的负载等于将这条边断开后形成的两个子树的节点数的乘积。
在计算一条边的负载的时候，可以将所有与之连通的点看成一棵树。只需要计算出一个端点的size大小就可以用size*(n-size)计算出答案。
由于这棵树的形态是已经确定的，可以先将这棵树建出来。每一次添加一条边肯定是在一对父子之间。那么将这条边连通无非是将父亲以及它能到的最远的祖先之间的点的size都加上儿子的size。那么我们可以用一个并查集来维护某个点最远到它的哪一个祖先都是连通的，然后每次修改size的时候用树链剖分修改树链就可以了。

代码

#include<iostream>
#include<cstring>
#include<cstdio>
using namespace std;
#define N 100005

int n,q,ans,x[N],y[N],f[N];
char opt[N];
int tot,point[N],v[N*2],nxt[N*2];
int dfs_clock,size[N],father[N],h[N],top[N],son[N],num[N],sum[N*4],delta[N*4];
bool vis[N];

void addedge(int x,int y)
{
    ++tot; nxt[tot]=point[x]; point[x]=tot; v[tot]=y;
    ++tot; nxt[tot]=point[y]; point[y]=tot; v[tot]=x;
}
void dfs_1(int x,int fa)
{
    vis[x]=true;
    size[x]=1; father[x]=fa; h[x]=h[fa]+1;
    for (int i=point[x];i;i=nxt[i])
        if (v[i]!=fa)
        {
            dfs_1(v[i],x);
            size[x]+=size[v[i]];
            if (size[son[x]]<size[v[i]]) son[x]=v[i];
        }
}
void dfs_2(int x,int fa)
{
    vis[x]=true;
    if (son[fa]==x) top[x]=top[fa];
    else top[x]=x;
    num[x]=++dfs_clock;
    if (son[x]) dfs_2(son[x],x);
    for (int i=point[x];i;i=nxt[i])
        if (v[i]!=fa&&v[i]!=son[x])
            dfs_2(v[i],x);
}

void update(int now)
{
    sum[now]=sum[now<<1]+sum[now<<1|1];
}
void pushdown(int now,int l,int r,int mid)
{
    if (delta[now]!=0)
    {
        sum[now<<1]+=delta[now]*(mid-l+1); delta[now<<1]+=delta[now];
        sum[now<<1|1]+=delta[now]*(r-mid); delta[now<<1|1]+=delta[now];
        delta[now]=0;
    }
}
void build(int now,int l,int r)
{
    int mid=(l+r)>>1;
    if (l==r)
    {
        sum[now]=1;
        return;
    }
    build(now<<1,l,mid);
    build(now<<1|1,mid+1,r);
    update(now);
}
void interval_change(int now,int l,int r,int lrange,int rrange,int add)
{
    int mid=(l+r)>>1;
    if (lrange<=l&&r<=rrange)
    {
        sum[now]+=add*(r-l+1);
        delta[now]+=add;
        return;
    }
    pushdown(now,l,r,mid);
    if (lrange<=mid) interval_change(now<<1,l,mid,lrange,rrange,add);
    if (mid+1<=rrange) interval_change(now<<1|1,mid+1,r,lrange,rrange,add);
    update(now);
}
int query(int now,int l,int r,int x)
{
    int mid=(l+r)>>1;
    if (l==r) return sum[now];
    pushdown(now,l,r,mid);
    if (x<=mid) return query(now<<1,l,mid,x);
    else return query(now<<1|1,mid+1,r,x);
}

void change(int u,int t,int add)
{
    int f1=top[u],f2=top[t];
    while (f1!=f2)
    {
        if (h[f1]<h[f2])
        {
            swap(f1,f2);
            swap(u,t);
        }
        interval_change(1,1,n,num[f1],num[u],add);
        u=father[f1];
        f1=top[u];
    }
    if (num[u]>num[t]) swap(u,t);
    interval_change(1,1,n,num[u],num[t],add);
}

int find(int x)
{
    if (x==f[x]) return x;
    f[x]=find(f[x]);
    return f[x];
}

int main()
{
    scanf("%d%d",&n,&q);
    for (int i=1;i<=q;++i)
    {
        char ch=getchar();
        while (ch!='A'&&ch!='Q') ch=getchar();
        opt[i]=ch;
        scanf("%d%d",&x[i],&y[i]);

        if (ch=='A') addedge(x[i],y[i]);
    }
    for (int i=1;i<=n;++i)
        if (!vis[i])
            dfs_1(i,0);
    memset(vis,0,sizeof(vis));
    for (int i=1;i<=n;++i)
        if (!vis[i])
            dfs_2(i,0);
    build(1,1,n);
    for (int i=1;i<=n;++i) f[i]=i;
    for (int i=1;i<=q;++i)
    {
        if (h[x[i]]>h[y[i]]) swap(x[i],y[i]);
        if (opt[i]=='A')
        {
            int fa=find(x[i]);
            int sz=query(1,1,n,num[y[i]]);
            change(fa,x[i],sz);
            f[y[i]]=fa;
        }
        else
        {
            int fa=find(x[i]);
            int szf=query(1,1,n,num[fa]);
            int szy=query(1,1,n,num[y[i]]);
            ans=szy*(szf-szy);
            printf("%d\n",ans);
        }
    }
}

手工栈

#include<iostream>
#include<cstring>
#include<cstdio>
using namespace std;
#define N 100005

int n,q,ans,x[N],y[N],f[N];
char opt[N];
int tot,point[N],v[N*2],nxt[N*2];
int dfs_clock,size[N],father[N],h[N],top[N],son[N],num[N],sum[N*4],delta[N*4];
bool vis[N];
int stack[N],cur[N];bool use[N];

void addedge(int x,int y)
{
    ++tot; nxt[tot]=point[x]; point[x]=tot; v[tot]=y;
    ++tot; nxt[tot]=point[y]; point[y]=tot; v[tot]=x;
}
void dfs_1(int st)
{
    int tmp=0;
    stack[++tmp]=st;vis[st]=1;size[st]=1;h[st]=1;
    while (tmp)
    {
        int x=stack[tmp];
        if (cur[x]&&v[cur[x]]==father[x]) cur[x]=nxt[cur[x]];
        if (!cur[x])
        {
            --tmp;
            if (father[x])
            {
                size[father[x]]+=size[x];
                if (size[x]>size[son[father[x]]]) son[father[x]]=x;
            }
            continue;
        }
        int vt=v[cur[x]];
        stack[++tmp]=vt;vis[vt]=1;
        size[vt]=1;h[vt]=h[x]+1;father[vt]=x;
        cur[x]=nxt[cur[x]];
    }
}
void dfs_2(int st)
{
    int tmp=0;
    stack[++tmp]=st;vis[st]=1;num[st]=++dfs_clock;top[st]=st;
    while (tmp)
    {
        int x=stack[tmp];
        if (!use[x])
        {
            use[x]=1;
            int vt=son[x];
            if (vt)
            {
                stack[++tmp]=vt;
                vis[vt]=1;
                top[vt]=top[x];
                num[vt]=++dfs_clock;
            }
            continue;
        }
        while (cur[x]&&(v[cur[x]]==son[x]||v[cur[x]]==father[x])) cur[x]=nxt[cur[x]];
        if (!cur[x])
        {
            --tmp;
            continue;
        }
        else
        {
            int vt=v[cur[x]];
            stack[++tmp]=vt;
            vis[vt]=1;
            top[vt]=vt;
            num[vt]=++dfs_clock;
            cur[x]=nxt[cur[x]];
        }
    }
}
void update(int now)
{
    sum[now]=sum[now<<1]+sum[now<<1|1];
}
void pushdown(int now,int l,int r,int mid)
{
    if (delta[now]!=0)
    {
        sum[now<<1]+=delta[now]*(mid-l+1); delta[now<<1]+=delta[now];
        sum[now<<1|1]+=delta[now]*(r-mid); delta[now<<1|1]+=delta[now];
        delta[now]=0;
    }
}
void build(int now,int l,int r)
{
    int mid=(l+r)>>1;
    if (l==r)
    {
        sum[now]=1;
        return;
    }
    build(now<<1,l,mid);
    build(now<<1|1,mid+1,r);
    update(now);
}
void interval_change(int now,int l,int r,int lrange,int rrange,int add)
{
    int mid=(l+r)>>1;
    if (lrange<=l&&r<=rrange)
    {
        sum[now]+=add*(r-l+1);
        delta[now]+=add;
        return;
    }
    pushdown(now,l,r,mid);
    if (lrange<=mid) interval_change(now<<1,l,mid,lrange,rrange,add);
    if (mid+1<=rrange) interval_change(now<<1|1,mid+1,r,lrange,rrange,add);
    update(now);
}
int query(int now,int l,int r,int x)
{
    int mid=(l+r)>>1;
    if (l==r) return sum[now];
    pushdown(now,l,r,mid);
    if (x<=mid) return query(now<<1,l,mid,x);
    else return query(now<<1|1,mid+1,r,x);
}

void change(int u,int t,int add)
{
    int f1=top[u],f2=top[t];
    while (f1!=f2)
    {
        if (h[f1]<h[f2])
        {
            swap(f1,f2);
            swap(u,t);
        }
        interval_change(1,1,n,num[f1],num[u],add);
        u=father[f1];
        f1=top[u];
    }
    if (num[u]>num[t]) swap(u,t);
    interval_change(1,1,n,num[u],num[t],add);
}

int find(int x)
{
    if (x==f[x]) return x;
    f[x]=find(f[x]);
    return f[x];
}

int main()
{
    scanf("%d%d",&n,&q);
    for (int i=1;i<=q;++i)
    {
        char ch=getchar();
        while (ch!='A'&&ch!='Q') ch=getchar();
        opt[i]=ch;
        scanf("%d%d",&x[i],&y[i]);

        if (ch=='A') addedge(x[i],y[i]);
    }
    for (int i=1;i<=n;++i) cur[i]=point[i];
    for (int i=1;i<=n;++i)
        if (!vis[i])
            dfs_1(i);
    memset(vis,0,sizeof(vis));
    for (int i=1;i<=n;++i) cur[i]=point[i];
    for (int i=1;i<=n;++i)
        if (!vis[i])
            dfs_2(i);
    build(1,1,n);
    for (int i=1;i<=n;++i) f[i]=i;
    for (int i=1;i<=q;++i)
    {
        if (h[x[i]]>h[y[i]]) swap(x[i],y[i]);
        if (opt[i]=='A')
        {
            int fa=find(x[i]);
            int sz=query(1,1,n,num[y[i]]);
            change(fa,x[i],sz);
            f[y[i]]=fa;
        }
        else
        {
            int fa=find(x[i]);
            int szf=query(1,1,n,num[fa]);
            int szy=query(1,1,n,num[y[i]]);
            ans=szy*(szf-szy);
            printf("%d\n",ans);
        }
    }
}
Clove_unique
关注
专栏目录
【BZOJ 4326】运输计划【树链剖分+差分+二分答案】
skysys的研究小屋
11-08 494
首先，此题要求最大值最小，容易可以想到二分。现在要想如何check显然，要变为虫洞的边应该在所有比mid值大的路径上，于是我们需要快速求出所有这类路径的交集上的最大边。我们可以用差分来进行求交集，之后乱搞一下就好了。上面是Cycleke的原话。#include<bits/stdc++.h> using namespace std; #define g() getchar() #define d(x)
【BZOJ 1036】[ZJOI2008]树的统计Count 【树链剖分+线段树】
skysys的研究小屋
10-27 484
裸题.. 开始的代码有个bug，开始的build() 函数是这样写的:void build(int u,int l,int r){ tr[u].l=l,tr[u].r=r; if(l==r){ tr[u].mx=tr[u].sum=val[l]; return; }; int mid=(l+r)>>1; build(ls,l,mi
洛谷 P4219 [BJOI2014]大融合 树链剖分
liangzihao1的博客
08-09 224
题目描述 小强要在 NNN 个孤立的星球上建立起一套通信系统。这套通信系统就是连接 NNN 个点的一个树。 这个树的边是一条一条添加上去的。在某个时刻，一条边的负载就是它所在的当前能够 联通的树上路过它的简单路径的数量。 例如，在上图中，现在一共有了 555 条边。其中， (3,8)(3,8)(3,8) 这条边的负载是 666 ，因 为有六条简单路径 2−3−82−3−82-3-8 , 2−3...
bzoj 4530: [Bjoi2014]大融合 （并查集+树链剖分+线段树）
clover_hxy的博客
09-24 442
4530: [Bjoi2014]大融合 Time Limit: 10 Sec  Memory Limit: 256 MB Submit: 140  Solved: 83 [Submit][Status][Discuss] Description 小强要在N个孤立的星球上建立起一套通信系统。这套通信系统就是连接N个点的一个树。 这个树的边是一条一条添加上去的。在某个时刻，一条边的负载
BZOJ4530 [Bjoi2014]大融合
neither_nor
05-19 2977
LCT维护子树大小即可 对于每个点维护siz代表splay上的子树大小，SIZ代表不在splay上的子树大小，Siz代表连在这个点上的虚子树的大小的和 旋转、access和link的时候更新这三个值即可 #include #include #include #include #include #include #include #include #include #include #incl
4530: [Bjoi2014]大融合
蒟蒻的Bzoj记录
03-26 277
题目链接题目大意：一棵树，动态加边，询问经过一条边的路径条数题解：LCT 维护子树信息我的收获：2333#include <bits/stdc++.h> using namespace std;#define ls c[x][0] #define rs c[x][1]const int N=1e5+10;int n,q; int c[N][2],fa[N],size[N],sum[N],stk[N]
【bzoj4530】【BJOI2014】【大融合】【dfs序+线段树合并+并查集】
sunshinezff的专栏
05-31 807
Description 小强要在N个孤立的星球上建立起一套通信系统。这套通信系统就是连接N个点的一个树。 这个树的边是一条一条添加上去的。在某个时刻，一条边的负载就是它所在的当前能够 联通的树上路过它的简单路径的数量。 例如，在上图中，现在一共有了5条边。其中，(3,8)这条边的负载是6，因 为有六条简单路径2-3-8,2-3-8-7,3-8,3-8-7,4-3-8,4-3-8-
bzoj4530: [Bjoi2014]大融合 //线段树分治+并查集
蒟蒻名曰Starria
12-25 574
bzoj4530: [Bjoi2014]大融合 题意 N<=1e5个点，Q<=1e5个操作。 支持加一条边(u,v)（保证图是森林）、询问经过边(u,v)的简单路径条数（保证(u,v)存在）。 如果不算询问的那条边，那么答案就是当前u的联通块大小*v的联通块大小。 所以每条边原本的出现时间（加边的时间~结束）会被询问分隔成几段，所有边的总段数依然是Q级别的。
BZOJ4530: [Bjoi2014]大融合（洛谷P4219）
forezxl的博客
03-09 367
LCT BZOJ题目传送门 洛谷题目传送门 显然答案为sz[x]∗sz[y]sz[x]∗sz[y]sz[x]*sz[y]，但是因为这棵树会“动”，不能每次求一遍答案。 设sz[x][0/1]sz[x][0/1]sz[x][0/1]表示x中虚边连接的/总的节点个数。那么有sz[x][1]=sz[x.l][1]+sz[x.r][1]+sz[x][0]+1sz[x][1]=sz[x.l][1]+...
BZOJ 2243 浅谈树链剖分+线段树
BerryKanry的博客
09-29 411
世界真的很大 前几次考试有一次树链剖分当场写挂之后调了一下午 一直耿耿于怀，于是乎找一道树链剖分的题来练手 虽然代码量略大但是调试起来还是比较轻松，一个小错误卡了一会儿 没搞明白root根本没有赋值为什么还能过样例 一直RE加上return就A了看题先：description： 给定一棵有n个节点的无根树和m个操作，操作有2类： 1、将节点a到节点b路径上所有点都染成颜色c；
【bzoj4530】[Bjoi2014]大融合 并查集+线段树合并
Oxer的专栏
05-18 1950
线段树合并好神啊，表示我这种傻逼只能想到树剖O(nlog^2n)做法 先把原树建出来，每次查询就等价于计算子节点的size*(父亲节点所在联通块的大小-子节点的size) 用并查集找到节点的祖先，维护子树size 这个东西可以用线段树合并来做，查询就是查询dfs序上的一段区间 好像LCT+启发式合并更快？ #include #include #include #include
bzoj4530: [Bjoi2014]大融合（线段树合并）
苟为蒟蒻又何妨
01-14 297
传送门 线段树合并菜题。 题意简述：nnn个点，支持连边以及查询一个点所在连通块中经过这个点的路径条数，保证这张图时刻为森林。 思路： 先建出所有操作完之后的树统计出dfsdfsdfs序 注意有可能是森林而不是树 然后用线段树合并维护每棵子树的sizesizesize即可。 为了方便，我们将每个节点的ininin作为下标插入线段树中，这样可以方便的统计出一棵子树在[inv,outv],v∈sub...
【BJOI2014】大融合
Luckfort
06-25 363
树链剖分&&递归爆栈的原因之一
[Bjoi2014]大融合
weixin_33857679的博客
07-02 99
[Bjoi2014]大融合 Time Limit:10 SecMemory Limit:256 MBSubmit:394Solved:244[Submit][Status][Discuss] Description 小强要在N个孤立的星球上建立起一套通信系统。这套通信系统就是连接N个点的一个树。 这个树的边是一条一条添加上去的。在某个时刻，一条边的负载就是它所在的当...
[Bjoi2014]大融合(树链剖分+树状数组+并查集)
CindyMarshall的博客
08-03 293
  题面传送门   题意看起来像是动态树LCT维护连通性和子树大小，其实就是动态树LCT LCT自然可以将这道题轻松切掉啦，不过鉴于本蒟蒻写LCT的水平仅限于模板，对于稍低级的树链剖分却比较熟练，所以对这题我选择了离线，用树链剖分预处理出dfs序，将子树映射到一段区间上，然后用并查集维护所在的树的树根（因为在连边的过程中其实形成的是一个森林），树状数组差分前缀和维护子树大小。 那么，说得...
[BZOJ1969][Ahoi2005]LANE 航线规划（树链剖分+并查集）
zyf2000
09-24 1103
Good start, no patient and tolerant, bear no satisfactory fruit.再好的开始，没有恒久的忍耐和包容，也结不出圆满的果实。
[BJOI2014]大融合
HT008的Blog
03-09 476
题目描述： 雾。 题目分析： 这道题的答案显然是： 这条边连接的两棵子树大小的乘积 但是我们需要在一棵LCT上维护子树大小 LCT维护子树信息 在LCT中的splay中，expose某个点并splay到根， 那么ta的实儿子记录的信息是这条链的信息，并不是我们想要的子树信息 而所有实儿子和虚儿子的信息才是我们想要求的子树信息 但是由于虚儿子“儿子认爹，爹不认儿子”的性质，无法在...
BZOJ 4530: [Bjoi2014]大融合【LCT】
aiweiluan5095的博客
07-05 120
4530: [Bjoi2014]大融合 【题目描述】 传送门 【题解】 我们需要维护两个值，子树的信息(W[])和虚儿子(a[])的信息。 void PushUp(int x){if(x) W[x]=W[Son[x][0]]+W[Son[x][1]]+a[x]+1;} 然后我们需要在Access中更新这个a[]的值。 vo...
【BJOI 2014】大融合
LYD729
06-25 435
Description 初始有N个点，接下来Q个操作，有两种操作 1 将不连通的x,y连边 2 询问经过边(x,y)的简单路径数量 对于100%的数据，1≤N,Q≤100000 链剖 所谓简单路径数量，就是从中间的边分开，两边的连通块点数之积 先把最终的树弄出来，转成有根树 链剖，每个点维护其子树大小 然后可以发现，连边后对于某一段链的子树大小是会有影响的 借助并查集来确定
【学习笔记】可持久化并查集（BZOJ3673）
最新发布
05-22
可持久化并查集是指在并查集基础上，新增了时间维度，即支持查询历史版本的并查集信息。 主要应用场景是需要记录数据变化历史的问题，比如线段树合并、动态图连通性等。 以下是实现可持久化并查集的基本思路： 1. 每个节点维护一个 father 数组，表示该节点的祖先节点 2. 对于每个版本，使用一个 map（键值对）来记录每个节点的祖先节点 3. 合并操作时，将两个节点的祖先节点找出来，若不同就将其中一个节点的祖先节点指向另一个节点的祖先节点 4. 查询操作时，查询对应版本的 map，返回节点的祖先节点 具体实现时，可以使用并查集路径压缩和按秩合并优化，以提高效率。 以下是代码实现（C++）：
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值