【BJOI2014】大融合

最新推荐文章于 2021-01-28 19:07:42 发布
最新推荐文章于 2021-01-28 19:07:42 发布
阅读量178 收藏 1
点赞数
分类专栏： 树链剖分 线段树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43823476/article/details/109482442
版权

题目

 

题解&&思路：

自己的思路：

首先这道题可以发现离线是可做的，然后因为自己太菜，没有发现加边更好做，于是一直在考虑删边

删边有点烦，首先对于删去一条边后它及它的祖先的siz都会影响，那么可以使用树剖，每个点记一下siz即可

但是还没完，这样做如果删边时会影响到连通性，因为是离线则一个点的最终祖先(这里表示从当前点一直往上直到不可走为止所到的点）是会变的，sb的我发现这个东西也可以用树剖维护一下，就变得可做了

代码：

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define inf 0x3f3f3f3f
const int MAXN = 1e5 + 3;
int id[MAXN] , n , m , head[MAXN] , cnt = 1 , inde , top[MAXN] , siz[MAXN] , fa[MAXN];
int dep[MAXN] , son[MAXN] , dfn[MAXN] , zfa[MAXN];
struct node{
    int op , x , y;
}ques[MAXN];
struct edge{
    int to , nex;
}G[MAXN<<1];
ll ans[MAXN];
char o[3];
void add_edge( int x , int y ){
    G[cnt].to = y , G[cnt].nex = head[x];
    head[x] = cnt ++;
}
void dfs( int x , int f , int zx ){
    zfa[x] = zx;
    siz[x] = 1;
    for( int i = head[x] ; i ; i = G[i].nex ){
        int v = G[i].to;
        if( v == f ) continue;
        fa[v] = x;
        dep[v] = dep[x] + 1;
        dfs( v , x , zx );
        siz[x] += siz[v];
        if( !son[x] || siz[son[x]] < siz[v] ) son[x] = v;
    }
}
void dfs1( int x , int f ){
    top[x] = f;
    id[x] = ++inde;dfn[inde] = x;
    if( !son[x] ) return ;
    dfs1( son[x] , f );
    for( int i = head[x] ; i ; i = G[i].nex ){
        int v = G[i].to;
        if(fa[x] == v || son[x] == v ) continue;
        dfs1( v , v );
    }
}
struct tree{
    int l , r , lazy1 , zx;
    ll sum, lazy;
}tre[MAXN<<2];
int min_( int x , int y ){
    if( x == inf ) return y;
    if( y == inf ) return x;
    if( dep[x] > dep[y] ) return x;
    return y;
}
void build( int i , int l , int r ){
    tre[i].l = l , tre[i].r = r , tre[i].lazy = 0 , tre[i].sum = 0 , tre[i].lazy1 = inf;
    if( l == r ){
        tre[i].sum = siz[dfn[l]];tre[i].zx = zfa[dfn[l]];
        return ;
    }
    int mid = l + r >> 1;
    build( i << 1 , l , mid );
    build( i << 1 | 1 , mid + 1, r );
}
void pushdown( int i ){
    if( tre[i].lazy ){
        tre[i<<1].sum -= tre[i].lazy , tre[i<<1|1].sum -= tre[i].lazy;
        tre[i<<1].lazy += tre[i].lazy , tre[i<<1|1].lazy += tre[i].lazy;
        tre[i].lazy = 0;
    }
    if( tre[i].lazy1 != inf ){
        tre[i<<1].zx = min_( tre[i<<1].zx , tre[i].lazy1 ) , tre[i<<1|1].zx = min_( tre[i<<1|1].zx , tre[i].lazy1 );
        tre[i<<1].lazy1 = min_( tre[i<<1].lazy1 , tre[i].lazy1 ) , tre[i<<1|1].lazy1 = min_( tre[i<<1|1].lazy1 , tre[i].lazy1 );
        tre[i].lazy1 = inf;
    }
}
void pushup( int i ){
    tre[i].sum = tre[i<<1].sum + tre[i<<1|1].sum;
    tre[i].zx = min_( tre[i<<1].zx , tre[i<<1|1].zx );
}
void modify( int i , int l , int r , int delta ){
    if( tre[i].l > r || tre[i].r < l ) return ;
    if( tre[i].l >= l && tre[i].r <= r ){
        tre[i].sum -= delta;
        tre[i].lazy += delta;
        return ;
    }
    pushdown( i );
    modify( i << 1 , l , r , delta );
    modify( i << 1 | 1, l , r , delta );
    pushup( i );
}
void modify1( int i , int l, int r , int p ){
    if( tre[i].l > r || tre[i].r < l ) return ;
    if( tre[i].l >= l && tre[i].r <= r ){
        tre[i].zx = min_( tre[i].zx , p );
        tre[i].lazy1 = min_( tre[i].lazy1 , p );
        return ;
    }
    pushdown( i );
    modify1( i << 1 , l , r , p );
    modify1( i << 1 | 1, l , r , p );
    pushup( i );
}
ll query( int i , int l , int r ){
    if( tre[i].l > r || tre[i].r < l ) return 0;
    if( tre[i].l >= l && tre[i].r <= r ){
        return tre[i].sum;
    }
    pushdown( i );
    ll su = query( i << 1 , l , r );
    su += query( i << 1 | 1, l , r );
    pushup( i );
    return su;
}
int query1( int i , int l , int r ){
    if( tre[i].l > r || tre[i].r < l ) return inf;
    if( tre[i].l >= l && tre[i].r <= r ){
        return tre[i].zx;
    }
    pushdown( i );
    int su = query1( i << 1 , l , r );
    su = min_( su , query1( i << 1 | 1, l , r ) );
    pushup( i );
    return su;
}
int main(){
   // freopen( "path.in" , "r" , stdin );
    //freopen( "path.out" , "w" , stdout );
    scanf( "%d%d" , &n , &m );
    for( int i = 1 ;i <= m; i ++ ){
        scanf( "%s" , o );
        if( o[0] == 'A' ){
            ques[i].op = 1;
            scanf( "%d%d" , &ques[i].x , &ques[i].y );
            add_edge( ques[i].x , ques[i].y );
            add_edge( ques[i].y , ques[i].x );
        }
        else{
            ques[i].op = 0;
            scanf( "%d%d" , &ques[i].x , &ques[i].y );
        }
    }
    for( int i = 1 ; i <= n ; i ++ ){
        if( !fa[i] ){
            dep[i] = 1;
            dfs( i , 0 , i );
        }
    }
    for( int i = 1 ; i <= n ; i ++ ){
        if( !fa[i] ){
            dfs1( i , i );
        }
    }
    build( 1 , 1 , n );
    for( int i = m ; i >= 1 ; i -- ){
        if( ques[i].op ){
            int x = ques[i].x , y = ques[i].y;
            if( dep[x] < dep[y] ) swap( x , y );
            int p2 = x , p = query( 1 , id[x] , id[x] ) , p1 = query1( 1 , id[x] , id[x] );
            x = y;
            while( top[x] != top[p1] ){
                modify( 1 , id[top[x]] , id[x] , p );
                x = fa[top[x]];
            }
            modify( 1 , id[p1] , id[x] , p );
            modify1( 1 , id[p2] , id[p2] + siz[p2] - 1 , p2 );
        }
        else{
            int x = ques[i].x , y = ques[i].y;
            if( dep[x] < dep[y] ) swap( x , y );
            y = query1( 1 , id[x] , id[x] );
            int p = query( 1 , id[y] , id[y] ) ;
            int p1 = query( 1 , id[x] , id[x] );
            ans[i] = 1ll *( p - p1 ) * p1;
        }
    }
    for( int i = 1 ; i <= m ; i ++ ){
        if( !ques[i].op ){
            printf( "%lld\n" , ans[i] );
        }
    }
    return 0;
}

代码很长，因为自己太菜了思路太复杂

本身思路是对的，然而自己从没有把树剖一次写对过，这次又挂了一个点，还是同样的modify:

while( top[x] != top[p1] ){
                modify( 1 , id[top[x]] , id[x] , p );
                x = fa[top[x]];
            }
            modify( 1 , id[top[p1]] , id[x] , p );
            modify1( 1 , id[p2] , id[p2] + siz[p2] - 1 , p2 );

 

理解起来就是我把modify范围写挂了。。。

之前写错while，这次写错modify，要加强练习啊

其它解：

还是考虑使用树剖，这时按顺序加边，可以使用一个并查集维护连通性，而它的最终祖先是可以通过并查集维护的，就会变得TM好写得多

为了加强自己练习，就把这道题用这种方法再重构一遍：

#include<bits/stdc++.h>
using namespace std;
#define ll long long
const int MAXN = 1e5 + 3;
int n , m , top[MAXN] , siz[MAXN] , dep[MAXN] , fa[MAXN] , fa1[MAXN] , id[MAXN] , zson[MAXN];
vector<int>G[MAXN];
struct tree{
    int l , r;
    ll lazy , sum;
}tre[MAXN<<2];
struct node{
    int op , x , y;
}q[MAXN];
void dfs( int x , int f ){
    siz[x] = 1;
    for( int i =0 ; i < G[x].size() ; i ++ ){
        int v = G[x][i];
        if( v == f ) continue;
        dep[v] = dep[x] + 1;
        fa[v] = x;
        dfs( v , x );
        siz[x] += siz[v];
        if( !zson[x] || siz[zson[x]] < siz[v] ) zson[x] = v;
    }
}
int inde;
void dfs1( int x , int f ){
    top[x] = f;
    id[x] = ++inde;
    if( !zson[x] ) return ;
    dfs1( zson[x] , f );
    for( int i = 0 ; i < G[x].size() ; i ++ ){
        int v = G[x][i];
        if( v == fa[x] || v==zson[x] ) continue;
        dfs1( v , v );
    }
}
int findSet( int x ){
    if( x != fa1[x] ) fa1[x] = findSet( fa1[x] ) ;
    return fa1[x];
}
void unionSet( int x , int y ){
    int u = findSet( x ) , v = findSet( y );
    if( u == v ) return;
    if( dep[u] < dep[v] ) fa1[v] = u;
    else fa1[u] = v;
}
void pushdown( int i ){
    if( tre[i].lazy ){
        tre[i<<1].lazy += tre[i].lazy , tre[i<<1|1].lazy += tre[i].lazy;
        tre[i<<1].sum += tre[i].lazy , tre[i<<1|1].sum += tre[i].lazy;
        tre[i].lazy = 0;
    }
}
void build( int i , int l , int r ){
    tre[i].l = l , tre[i].r = r , tre[i].lazy = tre[i].sum = 0;
    if( l == r){tre[i].sum = 1;return ;}
    int mid = l + r >> 1;
    build( i << 1 , l ,mid);
    build( i << 1 | 1,  mid + 1 ,r );
}
void modify( int i , int l , int r , int delta ){
    if( tre[i].l > r || tre[i].r < l ) return ;
    if( tre[i].l >= l && tre[i].r <= r ){
        tre[i].sum += delta;
        tre[i].lazy += delta;
        return ;
    }
    pushdown( i );
    modify( i << 1 , l , r, delta );
    modify( i << 1 | 1 , l , r , delta );
}
int query( int i , int l , int r ){
    if( tre[i].l > r || tre[i].r < l ) return 0;
    if( tre[i].l >= l && tre[i].r <= r ){
        return tre[i].sum;
    }
    pushdown( i );
    int an = query( i << 1 , l , r);
    an += query( i << 1 | 1 , l , r);
    return an;
}
int main(){
    scanf( "%d%d" , &n , &m );
    for( int i = 1 ; i <= m ; i ++ ){
        char o[3];
        scanf( "%s" , o );
        if( o[0] == 'A' )
            q[i].op = 1;
        else q[i].op = 0;
        scanf( "%d%d" , &q[i].x , &q[i].y );
        if( q[i].op ){
            G[q[i].x].push_back( q[i].y );
            G[q[i].y].push_back( q[i].x );
        }
    }
    for( int i = 1 ; i <= n ; i ++ ) fa1[i] = i;
    for( int i = 1 ;i <= n ; i ++ ){
        if( !fa[i]) {
            dep[i] = 1;
            dfs( i , 0 );
        }
    }
    for( int i = 1 ; i <= n ; i ++) {
        if( !fa[i] ){
            dfs1( i , i );
        }
    }
    build( 1, 1 , n );
    for( int i = 1 ;i <= m ; i++ ){
        if( q[i].op ){
            int x = q[i].x , y = q[i].y;
            if( dep[x] > dep[y] ) swap( x , y );
            unionSet( x , y );
            int la = findSet( x ) , q = query( 1 , id[y] , id[y] );
            while( top[x] != top[la] ){
                modify( 1 , id[top[x]] , id[x] , q );
                x = fa[top[x]];
            }
            modify( 1 , id[la] , id[x] , q );
        }
        else{
            int x = q[i].x , y = q[i].y;
            if( dep[x] > dep[y] ) swap( x , y );
            int la = findSet( x ) , p = query( 1 , id[la] , id[la] );
            int p1 = query( 1 , id[y] , id[y] );
            printf( "%lld\n" , 1ll * ( p - p1 ) * p1 );
        }
    }
}

花了25min rush掉了，代码能力还需加强，还不够快 

正解：

LCT

再见

BIT_jzx
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【bzoj4530】[Bjoi2014]大融合 并查集+线段树合并
Oxer的专栏
05-18 1945
线段树合并好神啊，表示我这种傻逼只能想到树剖O(nlog^2n)做法 先把原树建出来，每次查询就等价于计算子节点的size*(父亲节点所在联通块的大小-子节点的size) 用并查集找到节点的祖先，维护子树size 这个东西可以用线段树合并来做，查询就是查询dfs序上的一段区间 好像LCT+启发式合并更快？ #include #include #include #include
【BJOI 2014】大融合
LYD729
06-25 425
Description 初始有N个点，接下来Q个操作，有两种操作 1 将不连通的x,y连边 2 询问经过边(x,y)的简单路径数量 对于100%的数据，1≤N,Q≤100000 链剖 所谓简单路径数量，就是从中间的边分开，两边的连通块点数之积 先把最终的树弄出来，转成有根树 链剖，每个点维护其子树大小 然后可以发现，连边后对于某一段链的子树大小是会有影响的 借助并查集来确定
bzoj 4530: [Bjoi2014]大融合 （并查集+树链剖分+线段树）
clover_hxy的博客
09-24 425
4530: [Bjoi2014]大融合 Time Limit: 10 Sec  Memory Limit: 256 MB Submit: 140  Solved: 83 [Submit][Status][Discuss] Description 小强要在N个孤立的星球上建立起一套通信系统。这套通信系统就是连接N个点的一个树。 这个树的边是一条一条添加上去的。在某个时刻，一条边的负载
[BZOJ4530][Bjoi2014]大融合（树链剖分+并查集）
zyf2000
09-25 956
forgetting someone doesn’t mean never think of him, but thinking of him with a calm heart.
P4219 [BJOI2014]大融合 解题报告
日居月诸的博客
01-28 101
P4219 [BJOI2014]大融合 解题报告 P4219 大融合 题目大意 动态维护一个森林，完成以下操作： 连边 (u,v)(u,v)(u,v)。 查询假如把边 (u,v)(u,v)(u,v) 割断，形成的两个连通块的大小的乘积。值得注意的是，这个操作并不会真正割断边。 点数 n≤105n\le 10^5n≤105，询问数 q≤105q\le 10^5q≤105。 解题思路 看到连边，我们可以想到 LCT。那么我们可以发现，第二个操作其实是查询子树 szszsz 和。 那么问题来了，由于 LCT
BJOI 2013. 压力1
08-03
BJOI 2013. 压力1
BJOI2018 双人猜数游戏 题解
最新发布
09-14
BJOI2018 双人猜数游戏 题解
树的同构.rar
12-05
在计算机科学领域，树是一种非常重要的数据结构，它在算法设计和问题解决中扮演着核心角色。树的同构是研究树结构相似性的一个概念，是图论中的一个经典问题。这里我们将深入探讨树的同构及其相关知识点。...
BZOJ4530 [Bjoi2014]大融合
neither_nor
05-19 2944
LCT维护子树大小即可 对于每个点维护siz代表splay上的子树大小，SIZ代表不在splay上的子树大小，Siz代表连在这个点上的虚子树的大小的和 旋转、access和link的时候更新这三个值即可 #include #include #include #include #include #include #include #include #include #include #incl
【bzoj4530】【BJOI2014】【大融合】【dfs序+线段树合并+并查集】
sunshinezff的专栏
05-31 799
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]大融合
Elijahqi
02-12 667
http://www.elijahqi.win/2018/02/12/bzoj4530/ Description 小强要在N个孤立的星球上建立起一套通信系统。这套通信系统就是连接N个点的一个树。 这个树的边是一条一条添加上去的。在某个时刻，一条边的负载就是它所在的当前能够 联通的树上路过它的简单路径的数量。 例如，在上图中，现在一共有了5条边。其中，(3,8)这条边的负载是6，因 为有...
[BJOI2014]大融合
dayfs2560的博客
12-14 86
Portal 可以简单发现， 经过一条边的路径条数就是这条边左边的点数乘以右边的点数。 那么就只要动态维护一棵树两边的点的size就可以了。 那么就用\(整体的点数-子树的点数\)就是另外一部分的点数。 在LCT上，儿子有左儿子，右儿子和虚儿子之分。 那么我们在维护的时候就分类讨论一下就可以了。 注意到只有Link和access操作会改变虚儿子。 那么我们只要在这个时候维护虚儿子就可以了...
[Bjoi2014]大融合
weixin_33857679的博客
07-02 93
[Bjoi2014]大融合 Time Limit:10 SecMemory Limit:256 MBSubmit:394Solved:244[Submit][Status][Discuss] Description 小强要在N个孤立的星球上建立起一套通信系统。这套通信系统就是连接N个点的一个树。 这个树的边是一条一条添加上去的。在某个时刻，一条边的负载就是它所在的当...
BJOI2014 大融合 并查集+线段树合并
XianHaoMing的博客
08-09 973
大融合Description小强要在N个孤立的星球上建立起一套通信系统。这套通信系统就是连接N个点的一个树。这个树的边是一条一条添加上去的。在某个时刻，一条边的负载就是它所在的当前能够联通的树上路过它的简单路径的数量。例如，在上图中，现在一共有了5条边。其中，(3,8)这条边的负载是6，因为有六条简单路径22-33-88 , 22-33-88-77 , 33-88 , 33-88-77 , 44-3
JZOJ 3766【BJOI2014】大融合（lct维护子树大小）
Cold_Chair的博客
06-26 1025
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-7路过了(3,8)。
【BJOI2014】路径
LYD729
06-25 328
Description 在一个N个节点的无向图（没有自环、重边）上，每个点都有一个符号，可能是数字，也可能是加号、减号、乘号、除号、小括号。你要在这个图上数一数，有多少种走恰好K个节点的方法，使得路过的符号串起来能够得到一个算数表达式 算数表达式。路径的起点和终点可以任意选择。所谓算数表达式 算数表达式，就是由运算符连接起来的一系列数字。括号可以插入在表达式中以表明运算顺序。注意，你要处理各种情况，比
BJOI2014 路径
weixin_34388207的博客
08-14 102
3767. 【BJOI2014】路径(Standard IO) Time Limits:1000 msMemory Limits:262144 KB Description 在一个N个节点的无向图（没有自环、重边）上，每个点都有一个符号，可能是数字，也可能是加号、减号、乘号、除号、小括号。你要在这个图上数一数，有多少种走恰好K个节点...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值