【树链剖分】【点权】

最新推荐文章于 2022-08-08 10:49:48 发布
最新推荐文章于 2022-08-08 10:49:48 发布
阅读量1.2k 收藏
点赞数 1
CC 4.0 BY-SA版权
分类专栏： 树链剖分
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/FZHvampire/article/details/45872433
本文介绍了树链剖分算法的应用实例，通过两道题目详细展示了如何利用树链剖分解决树上的节点查询和更新问题。包括树链剖分的基本思想、数据结构的设计与维护、查询和更新操作的具体实现。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

[bzoj]1036: [ZJOI2008]树的统计Count

Time Limit: 10 Sec Memory Limit: 162 MB
Submit: 7568 Solved: 3109
[Submit][Status][Discuss]
Description

一棵树上有n个节点，编号分别为1到n，每个节点都有一个权值w。我们将以下面的形式来要求你对这棵树完成一些操作： I. CHANGE u t : 把结点u的权值改为t II. QMAX u v: 询问从点u到点v的路径上的节点的最大权值 III. QSUM u v: 询问从点u到点v的路径上的节点的权值和 注意：从点u到点v的路径上的节点包括u和v本身

Input

输入的第一行为一个整数n，表示节点的个数。接下来n – 1行，每行2个整数a和b，表示节点a和节点b之间有一条边相连。接下来n行，每行一个整数，第i行的整数wi表示节点i的权值。接下来1行，为一个整数q，表示操作的总数。接下来q行，每行一个操作，以“CHANGE u t”或者“QMAX u v”或者“QSUM u v”的形式给出。 对于100％的数据，保证1<=n<=30000，0<=q<=200000；中途操作中保证每个节点的权值w在-30000到30000之间。

Output

对于每个“QMAX”或者“QSUM”的操作，每行输出一个整数表示要求输出的结果。

Sample Input

4

1 2

2 3

4 1

4 2 1 3

12

QMAX 3 4

QMAX 3 3

QMAX 3 2

QMAX 2 3

QSUM 3 4

QSUM 2 1

CHANGE 1 5

QMAX 3 4

CHANGE 3 6

QMAX 3 4

QMAX 2 4

QSUM 3 4
Sample Output

4

1

2

2

10

6

5

6

5

16

树链剖分的模板题，直接放代码吧

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int N=50010;
int tot=1,num=0,n,m,point[N],next[N*10],pos[N]={0},siz[N]={0},v[N]={0};
int belong[N]={0},fa[N][20]={0},deep[N]={0},map[N];
bool use[N];
char ch[10];
struct S{
    int maxn,sum;
}tr[N*4];
struct C{
    int st,en;
}aa[N*10];
inline void add(int i,int j)
{  
    tot+=1;next[tot]=point[i];point[i]=tot;  
    aa[tot].st=i;aa[tot].en=j;
    tot+=1;next[tot]=point[j];point[j]=tot;  
    aa[tot].st=j;aa[tot].en=i;
}
inline void dfs1(int x)
{
    int i;
    siz[x]=1;
    use[x]=false;
    for(i=1;i<=14;++i){
        if(deep[x]<(1<<i)) break;
        fa[x][i]=fa[fa[x][i-1]][i-1];
    }
    for(i=point[x];i;i=next[i])
      if(use[aa[i].en]){
        fa[aa[i].en][0]=x;
        deep[aa[i].en]=deep[x]+1;
        dfs1(aa[i].en);
        siz[x]+=siz[aa[i].en];
      }
}
inline void dfs2(int x,int y)
{
    int i,k=0;
    num+=1;
    pos[x]=num;
    map[num]=x;
    belong[x]=y;
    for(i=point[x];i;i=next[i])
      if(deep[aa[i].en]>deep[x]&&siz[k]<siz[aa[i].en])
        k=aa[i].en;
    if(k==0) return ;
    dfs2(k,y);
    for(i=point[x];i;i=next[i])
      if(deep[aa[i].en]>deep[x]&&k!=aa[i].en)
        dfs2(aa[i].en,aa[i].en);
}
inline int LCA(int x,int y)
{
    int i;
    if(deep[x]<deep[y])swap(x,y);
    int t=deep[x]-deep[y];
    for(i=0;i<=14;++i)
        if(t&(1<<i))x=fa[x][i];
    for(i=14;i>=0;--i)
        if(fa[x][i]!=fa[y][i]) 
        {x=fa[x][i];y=fa[y][i];}
    if(x==y)return x;
    else return fa[x][0];
}
#define mid (l+r)/2
#define L k<<1,l,mid
#define R k<<1|1,mid+1,r
inline void build(int k,int l,int r)
{
    if(l==r){
        tr[k].maxn=tr[k].sum=v[map[l]];
        return ;
    }
    build(L);build(R);
    tr[k].maxn=max(tr[k<<1].maxn,tr[k<<1|1].maxn);
    tr[k].sum=tr[k<<1].sum+tr[k<<1|1].sum;
}
void insert(int k,int l,int r,int x,int y)
{
    if(l==r&&l==x){
        tr[k].sum=tr[k].maxn=y;
        return ;
    }
    if(x<=mid) insert(L,x,y);
    else insert(R,x,y);
    tr[k].maxn=max(tr[k<<1].maxn,tr[k<<1|1].maxn);
    tr[k].sum=tr[k<<1].sum+tr[k<<1|1].sum;  
}
inline int qurry(int k,int l,int r,int x,int y,int kind)
{
    int sum=0,maxn=-210000000;
    if(x<=l&&y>=r) return kind==0?tr[k].maxn:tr[k].sum;
    if(x<=mid){
        if(kind==0) maxn=max(maxn,qurry(L,x,y,kind));
        else sum+=qurry(L,x,y,kind);
    }
    if(y>mid){
        if(kind==0) maxn=max(maxn,qurry(R,x,y,kind));
        else sum+=qurry(R,x,y,kind);
    }
    return kind==0?maxn:sum;
}
inline int ask(int x,int y,int kind)
{
    int sum=0,maxn=-210000000;
    while(belong[x]!=belong[y]){
        if(kind==0) maxn=max(maxn,qurry(1,1,n,pos[belong[x]],pos[x],kind));
        else sum+=qurry(1,1,n,pos[belong[x]],pos[x],kind);
        x=fa[belong[x]][0];
    }
    if(kind==0) maxn=max(maxn,qurry(1,1,n,pos[y],pos[x],kind));
    else sum+=qurry(1,1,n,pos[y],pos[x],kind);
    return kind==0?maxn:sum;
}
int main()
{
    int i,j,x,y;
    scanf("%d",&n);
    memset(use,1,sizeof(use));
    for(i=1;i<n;++i){
        scanf("%d%d",&x,&y);
        add(x,y);
    }
    for(i=1;i<=n;++i) scanf("%d",&v[i]);
    dfs1(1);
    dfs2(1,1);
    build(1,1,n);
    scanf("%d",&m);
    while(m--){
        scanf("%*c%s%d%d",&ch,&x,&y);
        if(ch[0]=='C') insert(1,1,n,pos[x],y),v[x]=y;
        else{
            int lca=LCA(x,y);
            if(ch[1]=='M') printf("%d\n",max(ask(x,lca,0),ask(y,lca,0)));
            else printf("%d\n",ask(x,lca,1)+ask(y,lca,1)-v[lca]);
        }
    }
}

[bzoj]4034: [HAOI2015]T2

Time Limit: 10 Sec Memory Limit: 256 MB
Submit: 369 Solved: 151
[Submit][Status][Discuss]
Description

有一棵点数为 N 的树，以点 1 为根，且树点有边权。然后有 M 个

操作，分为三种：
操作 1 ：把某个节点 x 的点权增加 a 。
操作 2 ：把某个节点 x 为根的子树中所有点的点权都增加 a 。
操作 3 ：询问某个节点 x 到根的路径中所有点的点权和。
Input

第一行包含两个整数 N, M 。表示点数和操作数。

接下来一行 N 个整数，表示树中节点的初始权值。
接下来 N-1 行每行三个正整数 fr, to ， 表示该树中存在一条边 (fr, to) 。
再接下来 M 行，每行分别表示一次操作。其中第一个数表示该操
作的种类（ 1-3 ） ，之后接这个操作的参数（ x 或者 x a ） 。
Output

对于每个询问操作，输出该询问的答案。答案之间用换行隔开。

Sample Input

5 5

1 2 3 4 5

1 2

1 4

2 3

2 5

3 3

1 2 1

3 5

2 1 2

3 3
Sample Output

6

9

13

HINT

对于 100% 的数据， N,M<=100000 ，且所有输入数据的绝对值都不

思路：这道题怎家了一个对于所有子树的修改，我们只需要多记录一个以这个点为根的子树中在线段树中编号最大的点的编号是多少就可以了。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int N=100100;
int point[N],next[N*4],belong[N],siz[N],son[N],pos[N],deep[N];
int n,m,tot=1,num=0,fa[N];
long long tr[N*4],de[N*4],r[N];
bool use[N];
struct S{
    int st,en;
}aa[N*4];
inline void add(int x,int y)
{
    tot+=1;next[tot]=point[x];point[x]=tot;
    aa[tot].st=x;aa[tot].en=y;
    tot+=1;next[tot]=point[y];point[y]=tot;
    aa[tot].st=y;aa[tot].en=x;
}
inline void dfs_1(int x)
{
    int i;
    siz[x]=1;
    use[x]=false;
    for(i=point[x];i;i=next[i])
      if(use[aa[i].en]){
        deep[aa[i].en]=deep[x]+1;
        fa[aa[i].en]=x;
        dfs_1(aa[i].en);
        siz[x]+=siz[aa[i].en];
      }
}
inline void dfs_2(int x,int y)
{
    int i,k=0;
    num+=1;
    pos[x]=son[x]=num;
    belong[x]=y;
    for(i=point[x];i;i=next[i])
      if(deep[x]<deep[aa[i].en]&&siz[k]<siz[aa[i].en])
        k=aa[i].en;
    if(k==0) return ;
    dfs_2(k,y);son[x]=max(son[k],son[x]);
    for(i=point[x];i;i=next[i])
      if(deep[x]<deep[aa[i].en]&&k!=aa[i].en){
        dfs_2(aa[i].en,aa[i].en);
        son[x]=max(son[x],son[aa[i].en]);
    }
}
#define mid (l+r)/2
#define L k<<1,l,mid
#define R k<<1|1,mid+1,r
inline void paint(int k,int l,int r,long long z)
{
    de[k]+=z;
    tr[k]+=(r-l+1)*z;
}
inline void pushdown(int k,int l,int r)
{
    if(l==r) return ;
    paint(L,de[k]);
    paint(R,de[k]);
    de[k]=0;
}
inline void insert(int k,int l,int r,int x,long long y)
{
    if(l==r&&l==x){
        tr[k]+=y;
        return ;
    }
    pushdown(k,l,r);
    if(x<=mid) insert(L,x,y);
    else insert(R,x,y);
    tr[k]=tr[k<<1]+tr[k<<1|1];
}
inline void change(int k,int l,int r,int x,int y,long long z)
{
    if(x<=l&&y>=r){
        paint(k,l,r,z);
        return ;
    }
    pushdown(k,l,r);
    if(x<=mid) change(L,x,y,z);
    if(y>mid) change(R,x,y,z);
    tr[k]=tr[k<<1]+tr[k<<1|1];
}
inline long long qurey(int k,int l,int r,int x,int y)
{
    long long sum=0;
    if(x<=l&&y>=r) return tr[k];
    pushdown(k,l,r);
    if(x<=mid) sum+=qurey(L,x,y);
    if(y>mid) sum+=qurey(R,x,y);
    return sum;
}
inline long long ask(int x,int y)
{
    long long sum=0;
    while(belong[x]!=belong[y]){
        sum+=qurey(1,1,n,pos[belong[x]],pos[x]);
        x=fa[belong[x]];
    }
    sum+=qurey(1,1,n,pos[y],pos[x]);
    return sum;
}
int main()
{
    int i,j,x,t,root;
    long long y;
    memset(use,1,sizeof(use));
    scanf("%d%d",&n,&m);
    for(i=1;i<=n;++i) scanf("%lld",&r[i]);
    for(i=1;i<n;++i){
        scanf("%d%d",&x,&y);
        add(x,y);
    }
    dfs_1(1);
    dfs_2(1,1);
    for(i=1;i<=n;++i){
        insert(1,1,n,pos[i],r[i]);
        if(deep[i]==0) root=i;
    }
    while(m--){
        scanf("%d",&t);
        if(t==1||t==2){
            scanf("%d%lld",&x,&y);
            if(t==1) insert(1,1,n,pos[x],y);
            if(t==2) change(1,1,n,pos[x],son[x],y);
        }
        else{
            scanf("%d",&x);
            printf("%lld\n",ask(x,root));
        }
    }
}
LCT入门（动态树）（点权）（边权）
qq_2992427261
09-23 2139
LCT的用途： 1，在线链接link&cut（连接边，删除边） 2，查询连通性 3，维护链上信息 4，换根 5，维护子树信息。 等等： 基础知识： 1.伸展树（Splay Tree） ：支持链上求和，求最值，修改，等等操作， 2LCT（link cut tree）：是一棵树，长这样： 这上面有一些粗一点的边，我们把它称为重边；还有一些细一点的，我们把它称为轻边。 基本函数功能介绍： ac...
树链剖分模板 边权、点权区别
tangzhide123yy的博客
07-29 2541
熟练剖分详解见:https://blog.youkuaiyun.com/tangzhide123yy/article/details/77532880 熟练剖分一般有如下几个步骤: 1.dfs1（）求出fa,deep,size,son 2.dfs2（）求出top,p 3.add（）/Query （）树链剖分核心部分 4.updata（）线段树更新操作(如单点修改，区间修改) 5.query（）线段...
树链剖分（边权）
gebixiaofang的博客
10-22 426
#include&lt;bits/stdc++.h&gt; #define MAX 123466 #define ll long long using namespace std; struct Front_Link_Star{ int next,to; }edge[MAX&lt;&lt;1]; ll Ma,Mi; ll tree[MAX &lt;&lt; 2],lazy[MAX &l...
树链剖分_基于边权
aiyi9685的博客
07-18 196
1 /* 2 题意： 3 题解： 4 时间： 5 */ 6 7 #include <bits/stdc++.h> 8 using namespace std; 9 10 typedef long long LL; 11 const int MAXN = 100005; 12 const LL ...
poj3237 树链部分 边权模板
diaocuiguo2493的博客
02-18 120
Tree Time Limit:5000MS Memory Limit:131072K Total Submissions:7384 Accepted:2001 Description You are given a tree withNnodes. The tree’s nodes are nu...
【树链剖分】【边权】
Vampire
05-20 1751
QTREE - Query on a treeno tags You are given a tree (an acyclic undirected connected graph) with N nodes, and edges numbered 1, 2, 3…N-1.We will ask you to perfrom some instructions of the following
树链剖分及进阶 边权化点权 luogu4315 luogu1505
WWL0702的博客
11-04 423
树链剖分模板 点权 2遍dfs+线段树 #include <bits/stdc++.h> using namespace std; #define rep(i,a,n) for(int i=a;i<n;i++) #define per(i,a,n) for(int i=n-1;i>=a;i--) typedef long long ll; typedef double db; typedef pair<int,int> P; typedef vector<int&g
树链剖分(初学)
weixin_43823476的博客
09-19 215
首先看一下树链剖分是什么东西： 当我们要同时解决以下两个问题时： 1.求树上两点简单路径上的最大最小值(和） 2.修改树上两点简单路径上的边权(点权) 如果只用单独考虑，那么第一个就是树上差分，第二个是倍增，可是如果同时要有两个操作，那么时间复杂度就会大幅度退化，所以现在要用一个新的方法：树链剖分 它将一棵树剖成了几条链来组成，且每个点最多只会存在一条链上，且只出现一次。那么怎么进行剖分...
树链剖分_王天懿.ppt
09-14
1. **POJ 3237**：维护边权的修改和路径上边权的取反操作，可以利用树链剖分和线段树联合解决。 2. **BZOJ 3083**：改变路径上点的权值和查询子树最小值，同样可以通过树链剖分实现。 3. **BZOJ 3531**：改变点的...
对LCA、树上倍增、树链剖分（重链剖分&长链剖分）和LCT（Link-Cut Tree）的学习
热门推荐
路人黑的纸巾
10-18 1万+
一篇从浅到深探究一些树上算法的博客
POJ 3237 Tree 树链剖分 边权
09-15 360
这个题目比SPOJ的QTree多了一个u->v内所有边的边权都变为相反数的操作，其他的都是类似的，单点更新，区间查询最大值。 因为有了取反操作，因为最小值的相反数是最大值，最大值的相反数是最小值..所以线段树要多记录一个最小值... 用这个题的代码我过了SPOJ那个QTREE，当时那个RE错误..并不懂是怎么犯的.. #include #include #include #include #
树链剖分边权版
maze_illusion的博客
08-30 272
int tol,head[maxn]; struct edge { int to,next; }es[maxm]; void addedge( int u , int v ) { es[tol].to = v; es[tol].next = head[u]; head[u] = tol++; } int top[maxn],fa[maxn],dep[maxn],s...
POJ 3237 Tree(树链剖分——边权)
weishengmingerfendou的专栏
11-05 430
题目链接：http://poj.org/problem?id=3237 分析： 练手题， 做模板。 #include #include #include #include using namespace std; #define lson l, m, rt<<1 #define rson m+1, r, rt<<1|1 const int maxn = 1e4 + 100; int Add
poj 3237 tree 树链剖分（边权）
JZK-Keven 的博客
05-02 286
将所有的边权变为边上两点里面的深度更大的节点的点权，然后在更新的时候，最后的一条链如果是一个点的话就不更新，反之，从头节点的儿子开始更新，即不更新头节点 Code： #include <iostream> #include <stdio.h> #include <algorithm> #include <cstring> using names...
图论：树链剖分-边权
weixin_30810239的博客
09-20 345
给一个数，边之间有权值，然后两种操作，第一种：求任意两点的权值和，第二，修改树上两点的权值 1 #include <cstdio> 2 #include <cstring> 3 #include <vector> 4 #include <algorithm> 5 using namespace std; 6 #...
树链剖分——边权poj2763
weixin_30369041的博客
04-23 158
边权操作起来也和点权一样，只要把边的权值映射到点上即可，要注意的地方是向上爬的过程中和点权不太一样，还有个特判(WA了几次。。) 完整代码 #include<cstring> #include<cstdio> #include<iostream> using namespace std; #define maxn 100005 struct...
【树链剖分】SPOJ 375 Query on a tree 裸题
Kewowlo
01-25 695
题目链接：点击打开链接 #include #include #include #include using namespace std; const int maxn=101010+5; const int maxm=maxn+maxn; #define lson l,m,rt<<1 #define rson m+1,r,rt<<1|1 struct EDGENODE{
poj 3237 Tree（树链剖分---边权化点权）
雪的期许
08-13 570
Tree Time Limit: 5000MS   Memory Limit: 131072K Total Submissions: 11989   Accepted: 3088 Description You are given a tree with N nodes. The tree’s nodes ...
C. 点权
m0_62008337的博客
08-08 247
%%%
长链剖分可处理可合并的与深度有关的子树信息(例如某深度点数、某深度点权和)
最新发布
02-25
我记得它和重链剖分类似，但重链剖分选择子树大小最大的子节点作为重儿子，而长链剖分选择的是最深子树深度最大的子节点作为长儿子。这样形成的链叫做长链，每个长链的长度对应其深度。那这样剖分后的结构有什么特点...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值