【HDU】5221 Occupation【树链剖分】

最新推荐文章于 2019-07-12 17:15:00 发布
最新推荐文章于 2019-07-12 17:15:00 发布
阅读量1.1k 收藏
点赞数
分类专栏： 树链剖分
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013368721/article/details/45457715
版权

传送门：【HDU】5221 Occupation

题目分析：

最直接的想法，用一棵树链剖分维护路径，一棵dfs序线段树维护子树。因为每次最多修改一个点，所以修改的时候我们暴力修改每个点就可以了。

my  code: 


#pragma comment(linker, "/STACK:102400000,102400000")
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <algorithm>
using namespace std ;

typedef long long LL ;

#define clr( a , x ) memset ( a , x , sizeof a )
#define cpy( a , x ) memcpy ( a , x , sizeof a )
#define ls ( o << 1 )
#define rs ( o << 1 | 1 )
#define lson ls , l , m
#define rson rs , m + 1 , r
#define root 1 , 1 , n
#define mid ( ( l + r ) >> 1 )

const int MAXN = 100005 ;
const int MAXE = 200005 ;
const int INF = 0x3f3f3f3f ;

struct Edge {
    int v , n ;
    Edge () {}
    Edge ( int v , int n ) : v ( v ) , n ( n ) {}
} ;

Edge E[MAXE] ;
int H[MAXN] , cntE ;
int tpos[2][MAXN << 2] ;
int tin[2][MAXN] ;
int top[MAXN] ;
int siz[MAXN] ;
int pre[MAXN] ;
int dep[MAXN] ;
int pos[MAXN] ;
int son[MAXN] ;
int val[MAXN] ;
int dfs_clock ;
int idx[MAXN] ;
int ou[MAXN] ;
bool c[MAXN] ;
int tree_idx ;
int n , q ;
int ans ;

void init () {
    ans = 0 ;
    cntE = 0 ;
    tree_idx = 0 ;
    dfs_clock = 0 ;
    clr ( H , -1 ) ;
}

void addedge ( int u , int v ) {
    E[cntE] = Edge ( v , H[u] ) ;
    H[u] = cntE ++ ;
}

void dfs ( int u ) {
    idx[u] = ++ dfs_clock ;
    tin[1][dfs_clock] = u ;
    siz[u] = 1 ;
    son[u] = 0 ;
    for ( int i = H[u] ; ~i ; i = E[i].n ) {
        int v = E[i].v ;
        if ( v == pre[u] ) continue ;
        pre[v] = u ;
        dep[v] = dep[u] + 1 ;
        dfs ( v ) ;
        siz[u] += siz[v] ;
        if ( siz[son[u]] < siz[v] ) son[u] = v ;
    }
    ou[u] = dfs_clock ;
}

void rebuild ( int u , int top_element ) {
    top[u] = top_element ;
    pos[u] = ++ tree_idx ;
    tin[0][tree_idx] = u ;
    if ( son[u] ) rebuild ( son[u] , top_element ) ;
    for ( int i = H[u] ; ~i ; i = E[i].n ) {
        int v = E[i].v ;
        if ( v != pre[u] && v != son[u] ) rebuild ( v , v ) ;
    }
}

void build ( int o , int l , int r ) {
    if ( l == r ) {
        tpos[0][o] = tin[0][l] ;
        tpos[1][o] = tin[1][l] ;
        return ;
    }
    int m = mid ;
    build ( lson ) ;
    build ( rson ) ;
    tpos[0][o] = max ( tpos[0][ls] , tpos[0][rs] ) ;
    tpos[1][o] = max ( tpos[1][ls] , tpos[1][rs] ) ;
}

void update ( int x , int i , int v , int o , int l , int r ) {
    if ( l == r ) {
        tpos[i][o] = v ? tin[i][l] : 0 ;
        return ;
    }
    int m = mid ;
    if ( x <= m ) update ( x , i , v , lson ) ;
    else update ( x , i , v , rson ) ;
    tpos[i][o] = max ( tpos[i][ls] , tpos[i][rs] ) ;
}

int query ( int L , int R , int i , int o , int l , int r ) {
    if ( L <= l && r <= R ) return tpos[i][o] ;
    int m = mid ;
    if ( R <= m ) return query ( L , R , i , lson ) ;
    if ( m <  L ) return query ( L , R , i , rson ) ;
    return max ( query ( L , R , i , lson ) , query ( L , R , i , rson ) ) ;
}

void Update1 ( int x , int y ) {
    while ( top[x] != top[y] ) {
        if ( dep[top[x]] < dep[top[y]] ) swap ( x , y ) ;
        while ( 1 ) {
            int t = query ( pos[top[x]] , pos[x] , 0 , root ) ;
            if ( !t ) break ;
            c[t] = 0 ;
            update ( pos[t] , 0 , 0 , root ) ;
            update ( idx[t] , 1 , 0 , root ) ;
            ans += val[t] ;
            //printf ( "%d\n" , t ) ;
        }
        x = pre[top[x]] ;
    }
    if ( dep[x] > dep[y] ) swap ( x , y ) ;
    while ( 1 ) {
        int t = query ( pos[x] , pos[y] , 0 , root ) ;
        if ( !t ) break ;
        c[t] = 0 ;
        update ( pos[t] , 0 , 0 , root ) ;
        update ( idx[t] , 1 , 0 , root ) ;
        ans += val[t] ;
    }
}

void Update2 ( int L , int R ) {
    while ( 1 ) {
        int t = query ( L , R , 1 , root ) ;
        if ( !t ) break ;
        c[t] = 0 ;
        update ( pos[t] , 0 , 0 , root ) ;
        update ( idx[t] , 1 , 0 , root ) ;
        ans += val[t] ;
    }
}

void solve () {
    int u , v , op ;
    init () ;
    scanf ( "%d" , &n ) ;
    for ( int i = 1 ; i <= n ; ++ i ) {
        scanf ( "%d" , &val[i] ) ;
        c[i] = 1 ;
    }
    for ( int i = 1 ; i < n ; ++ i ) {
        scanf ( "%d%d" , &u , &v ) ;
        addedge ( u , v ) ;
        addedge ( v , u ) ;
    }
    dfs ( 1 ) ;
    rebuild ( 1 , 1 ) ;
    build ( root ) ;
    scanf ( "%d" , &q ) ;
    for ( int i = 0 ; i < q ; ++ i ) {
        scanf ( "%d" , &op ) ;
        if ( op == 1 ) {
            scanf ( "%d%d" , &u , &v ) ;
            Update1 ( u , v ) ;
        } else if ( op == 2 ) {
            scanf ( "%d" , &u ) ;
            if ( !c[u] ) {
                c[u] = 1 ;
                update ( pos[u] , 0 , 1 , root ) ;
                update ( idx[u] , 1 , 1 , root ) ;
                ans -= val[u] ;
            }
        } else {
            scanf ( "%d" , &u ) ;
            Update2 ( idx[u] , ou[u] ) ;
        }
        printf ( "%d\n" , ans ) ;
    }
}

int main () {
    int T ;
    scanf ( "%d" , &T ) ;
    for ( int i = 1 ; i <= T ; ++ i ) {
        solve () ;
    }
    return 0 ;
}

然而我们可以发现，树链剖分是有dfs序，然后我们就可以发现对于一个节点的子树，其子树构成的区间也是连续的，那么我们只需要一个树链剖分就够了。

my  code: 


#pragma comment(linker, "/STACK:102400000,102400000")
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <algorithm>
using namespace std ;

typedef long long LL ;

#define clr( a , x ) memset ( a , x , sizeof a )
#define cpy( a , x ) memcpy ( a , x , sizeof a )
#define ls ( o << 1 )
#define rs ( o << 1 | 1 )
#define lson ls , l , m
#define rson rs , m + 1 , r
#define root 1 , 1 , n
#define mid ( ( l + r ) >> 1 )

const int MAXN = 100005 ;
const int MAXE = 200005 ;
const int INF = 0x3f3f3f3f ;

struct Edge {
    int v , n ;
    Edge () {}
    Edge ( int v , int n ) : v ( v ) , n ( n ) {}
} ;

Edge E[MAXE] ;
int H[MAXN] , cntE ;
int tpos[MAXN << 2] ;
int tree[MAXN] ;
int top[MAXN] ;
int siz[MAXN] ;
int pre[MAXN] ;
int dep[MAXN] ;
int pos[MAXN] ;
int son[MAXN] ;
int val[MAXN] ;
int idx[MAXN] ;
int dfs_clock ;
bool c[MAXN] ;
int tree_idx ;
int in[MAXN] ;
int ou[MAXN] ;
int n , q ;
int ans ;

void init () {
    ans = 0 ;
    cntE = 0 ;
    tree_idx = 0 ;
    dfs_clock = 0 ;
    clr ( H , -1 ) ;
}

void addedge ( int u , int v ) {
    E[cntE] = Edge ( v , H[u] ) ;
    H[u] = cntE ++ ;
}

void dfs ( int u ) {
    siz[u] = 1 ;
    son[u] = 0 ;
    for ( int i = H[u] ; ~i ; i = E[i].n ) {
        int v = E[i].v ;
        if ( v == pre[u] ) continue ;
        pre[v] = u ;
        dep[v] = dep[u] + 1 ;
        dfs ( v ) ;
        siz[u] += siz[v] ;
        if ( siz[son[u]] < siz[v] ) son[u] = v ;
    }
    ou[u] = dfs_clock ;
}

void rebuild ( int u , int top_element ) {
    in[u] = ++ dfs_clock ;
    top[u] = top_element ;
    pos[u] = ++ tree_idx ;
    idx[tree_idx] = u ;
    if ( son[u] ) rebuild ( son[u] , top_element ) ;
    for ( int i = H[u] ; ~i ; i = E[i].n ) {
        int v = E[i].v ;
        if ( v != pre[u] && v != son[u] ) rebuild ( v , v ) ;
    }
    ou[u] = dfs_clock ;
}

void build ( int o , int l , int r ) {
    tpos[o] = idx[l] ;
    if ( l == r ) {
        tree[l] = o ;
        return ;
    }
    int m = mid ;
    build ( lson ) ;
    build ( rson ) ;
}

void update ( int x , int v ) {
    int o = tree[x] ;
    tpos[o] = v ? idx[x] : 0 ;
    while ( o > 1 ) {
        o >>= 1 ;
        tpos[o] = max ( tpos[ls] , tpos[rs] ) ;
    }
}

int query ( int L , int R , int o , int l , int r ) {
    if ( L <= l && r <= R ) return tpos[o] ;
    int m = mid ;
    if ( R <= m ) return query ( L , R , lson ) ;
    if ( m <  L ) return query ( L , R , rson ) ;
    return max ( query ( L , R , lson ) , query ( L , R , rson ) ) ;
}

void Update1 ( int x , int y ) {
    while ( top[x] != top[y] ) {
        if ( dep[top[x]] < dep[top[y]] ) swap ( x , y ) ;
        while ( 1 ) {
            int t = query ( pos[top[x]] , pos[x] , root ) ;
            if ( !t ) break ;
            c[t] = 0 ;
            update ( pos[t] , 0 ) ;
            ans += val[t] ;
            //printf ( "%d\n" , t ) ;
        }
        x = pre[top[x]] ;
    }
    if ( dep[x] > dep[y] ) swap ( x , y ) ;
    while ( 1 ) {
        int t = query ( pos[x] , pos[y] , root ) ;
        if ( !t ) break ;
        c[t] = 0 ;
        update ( pos[t] , 0 ) ;
        ans += val[t] ;
    }
}

void Update2 ( int L , int R ) {
    while ( 1 ) {
        int t = query ( L , R , root ) ;
        if ( !t ) break ;
        c[t] = 0 ;
        update ( pos[t] , 0 ) ;
        ans += val[t] ;
    }
}

void solve () {
    int u , v , op ;
    init () ;
    scanf ( "%d" , &n ) ;
    for ( int i = 1 ; i <= n ; ++ i ) {
        scanf ( "%d" , &val[i] ) ;
        c[i] = 1 ;
    }
    for ( int i = 1 ; i < n ; ++ i ) {
        scanf ( "%d%d" , &u , &v ) ;
        addedge ( u , v ) ;
        addedge ( v , u ) ;
    }
    dfs ( 1 ) ;
    rebuild ( 1 , 1 ) ;
    build ( root ) ;
    scanf ( "%d" , &q ) ;
    for ( int i = 0 ; i < q ; ++ i ) {
        scanf ( "%d" , &op ) ;
        if ( op == 1 ) {
            scanf ( "%d%d" , &u , &v ) ;
            Update1 ( u , v ) ;
        } else if ( op == 2 ) {
            scanf ( "%d" , &u ) ;
            if ( !c[u] ) {
                c[u] = 1 ;
                update ( pos[u] , 1 ) ;
                ans -= val[u] ;
            }
        } else {
            scanf ( "%d" , &u ) ;
            Update2 ( in[u] , ou[u] ) ;
        }
        printf ( "%d\n" , ans ) ;
    }
}

int main () {
    int T ;
    scanf ( "%d" , &T ) ;
    for ( int i = 1 ; i <= T ; ++ i ) {
        solve () ;
    }
    return 0 ;
}
poursoul
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
hdu_5221_Occupation(树剖)
bin_gege的博客
06-28 345
题目连接：http://acm.hdu.edu.cn/showproblem.php?pid=5221 题意：给你一棵树，每个节点有一定的值，有三种操作： 1 x y 表示占领树上x-y的所有节点，2 x 表示去掉这点，3 x表示占领以这个节点为根的所有节点 题解：1 2 都是树剖操作，3则要记录树剖的时间戳，一个根节点下的点的新编号都是连续的，所以只要记录该根节点的最大时间戳就知道这个区间了
HDU 5221 树链剖分
新熊君的博客
07-20 433
题目链接题意很简单。对于前两个操作，一个是树链剖分的经典路径更新，另外一个是线段的单点更新。难点就在于第三个操作怎么来处理。关于子树的更新，很显然跟dfs序有关，如果观察第二个更新重链的dfs，易发现，其实标号的过程也是一个dfs序的过程，只不过优先走的重儿子的路径。而关于标号跟子树的关系，可以看下图：（图片来源于网络 侵删）易看出 以u为根节点的子树的标号一定连续，且为： tid[u]−−>tid
HDU 5221 Occupation（树链剖分）
Tongqi
09-23 725
题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=5221 题意：有个人想占领一棵树上的城市，有三种操作： 1.占领(u, v)间的所有城市 2.失去u城市 3.占领以u点为根的所有城市 每次操作后输出他所占领的所有城市权值和 思路：对于1，2操作是树剖的基本操作，而对于3操作，可以在剖分时记录下每个点的子树的最大时间戳，这样因为...
hdu 5221 Occupation（树链剖分）
glq007的acm的奋斗
05-09 681
题意：1棵树，3个操作，1.占据从x走到y的路。2。某个点被另一个占据，3.占据以某个点及以下的子树。每次操作都要输出占有权值的和。 1操作就是类似查询的操作，走一遍更新。2操作先看那个点有没有被占据，有才需要更新成没有。3操作，由于树链剖分其实本质就是一个先走重链的dfs序，所以是连续的，就可以区间更新了。 AC代码： #pragma comment(linker, "/STACK:102
"BestCoder"杯中国大学生程序设计冠军赛 HDU 5221 Occupation
Linux猿
05-03 2538
"BestCoder"杯中国大学生程序设计冠军赛 HDU 5221 Occupation
hdu 5221 Occupation
llin-黎辰
06-13 625
Occupation Time Limit: 12000/6000 MS (Java/Others)    Memory Limit: 131072/131072 K (Java/Others) Total Submission(s): 269    Accepted Submission(s): 93 Problem Description Miceren finds a hug
HDU 5221 Occupation
Mr.Phoebe的专栏
08-21 738
算是一个比较裸的树链剖分。。。但是为什么比赛的时候没人做。。。 树上每个点都有权值 3个操作 1° ans += u~v路径上点权值之和 2° 将点u的权值从ans中剔除 3° ans += 以u为root的子树的点权之和1和2都是树链剖分的基本操作。至于3，如果你是dfs建图的话，那么你剖出来的点的序号终究是他们的dfs序，所以一个u的子树在序中的范围就是id[u] + size[u]
树链剖分 - hdu5221 Occupation
Keith_windniw的专栏
08-11 367
题目： http://acm.hdu.edu.cn/showproblem.php?pid=5221 题意： 给定一棵树，每个结点上有一个权值，然后给Q个操作，每个操作为：1. 占领这个树上两个结点路径上的所有结点，包括起点和终点；2. 取消某个结点的占领； 3. 占领以某个结点为根的整棵子树； 对于每个操作，返回完成这个操作后整棵树被占领结点的权值之和 思路： 操作
hdu5759 线段树+树剖
GAUSS_CLB
07-27 879
题解已经放出来了，可以推一下上面的公式。关键这题要维护很多信息，当发生一次修改节点u，我们需要用两颗线段树分别维护u的孩子层和u的孙子层，由于是区间修改，所以需要使用bfs序才能使这些点连续。对于修改u，就直接改好了，最后麻烦的是要修改从u的父亲到根的整条链，用树剖改整条链可以吗？显然不可以。。。因为size(v)-size(w)是变化的，那么从另一个角度考虑，对于某个节点v，遍历所有孩子，对于每
2018.09.27【BZOJ5221】偏题（矩阵快速幂）（数学推理）
zxyoi_dreamer的博客（不定期诈尸）
09-27 204
【问题描述】 斐波那契数列是一个经典递推数列，即Fibn=Fibn−1+Fibn−2Fib_n=Fib_{n-1}+Fib_{n-2}Fibn​=Fibn−1​+Fibn−2​ 在这个问题中，定义一个新数列，对于n≥2n ≥ 2n≥2有Fn=Fn−1+Fn−2+3+Fn−1Fn−2F_n=F_{n-1}+F_{n-2}+\sqrt{3+F_{n-1}F_{n-2}}Fn​=Fn−1​+Fn−2​+...
hdu acm1166线段树
05-03
hdu 1166线段树代码
hdu.rar_hdu
最新发布
09-23
3. **数据结构**：数组、链表、栈、队列、树（二叉树、平衡树如AVL和红黑树）、图（邻接矩阵、邻接表、最小生成树、拓扑排序等）。 4. **字符串处理**：KMP算法、Manacher's Algorithm、Rabin-Karp算法等。 5. **...
二叉搜索树练习 HDU3791
04-14
总结来说，"二叉搜索树练习 HDU3791"是一道关于二叉搜索树操作的编程题，可能需要实现插入、删除、查找等基本操作，并通过分析`Main.java`源码来理解和解决问题。同时，可能需要借助各种工具进行调试和测试，以确保...
hdu.zip_ACM_hdu
09-20
在ACM(国际大学生程序设计竞赛)中，数据结构与算法是至关重要的组成部分，而"杭电"(杭州电子科技大学)的在线判题系统HDU提供了许多这类问题供参赛者练习。"hdu.zip_ACM_hdu"这个压缩包很可能是包含了一道或若干道...
数据结构课程实践哈夫曼树
12-22
HDU（杭州电子科技大学）的这个数据结构课程实践项目使用JavaScript实现了哈夫曼树的基本操作，虽然可能只实现了基本的功能，但足以提供一个直观的学习和实践平台。 哈夫曼树的核心概念是通过对具有不同权重的叶子...
Occupation hdu5221 树链剖分
weixin_30389003的博客
07-12 172
题意: 一开始有n个点 且每个点有其价值 有三个操作 1 选取路径 x y 并获得其价值 2 删除x的价值 也就是放弃x （如果x未选择就不用删除） 3 选取x及x的子树 每次询问都要输出获得的价值总和 三个操作都很简单 主要是是线段树有一点不一样 用前缀和可以解决 见代码 #include<bits/stdc++.h> ...
hdu 5221 Meeting 建图+迪杰斯特拉
便纵有千种风情
10-31 655
Meeting Time Limit: 12000/6000 MS (Java/Others)    Memory Limit: 262144/262144 K (Java/Others) Total Submission(s): 30    Accepted Submission(s): 7 Problem Description Bessie and her frien
Hdu 5221 Occupation
lambda QAQ
12-01 341
算是一个简单的树剖+线段树（不过话说回来树剖也是经常和线段树一起（这个题应该叫做线段树在树上的简单应用（Orz 感觉自己的线段树（特别是区间更新这个地方）还是很不熟练 （观看下文需要一些简单的线段树知识，包括但不限于线段树的定义） 如果不考虑树上的部分的话，这个题要求我们维护一个区间，其中区间中的每一个点都有一个标记和一个value，刚开始的时候，标记都是false 1 将
BZOJ5221[Lydsy2017省队十连测] 偏题
ShadyPi的IT笔记
09-27 256
原题链接：https://www.lydsy.com/JudgeOnline/problem.php?id=5221 偏题 Description 斐波那契数列是一个经典递推数列，即 Fibn=Fibn−1+Fin+n−2Fib_n=Fib_{n-1}+Fin+{n-2}Fibn​=Fibn−1​+Fin+n−2 在这个问题中，定义一个新数列，对于n≥2n ≥ 2n≥2有 Fn=Fn−1+Fn−...
计算几何基础：凸多边形三角剖分与面积求解
"凸多边形的三角形剖分-ACM课件!!(lecture_07)计算几何基础_easy" 这篇课件主要介绍了计算几何中的一个基础概念——凸多边形的三角形剖分，这是 ACM 程序设计和算法学习中的一个重要主题。在计算几何领域，对多边形...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值