bzoj1984 月下“毛景树”(边权的树链剖分)

最新推荐文章于 2021-09-22 18:41:38 发布
原创 最新推荐文章于 2021-09-22 18:41:38 发布 · 485 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文介绍了一种高效的数据结构——树链剖分，结合线段树实现单点修改、区间修改等操作。文章详细展示了如何通过树链剖分将树形结构上的查询和更新操作转化为线段树上的操作，特别适用于处理复杂的路径查询问题。

树链剖分，挺裸的，给的是边权，我们把边权都记在儿子上。用线段树维护单点修改，区间修改，区间加，区间最大值。需要注意的是对路径（x，y）进行操作时，不应算lca(x,y)这一点。因为他所代表的边不在路径上。

#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define inf 0x3f3f3f3f
#define N 100010
inline int read(){
    int x=0,f=1;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9') x=x*10+ch-'0',ch=getchar();
    return x*f;
}
int n,a[N],p[N],w[N],h[N],dep[N],fa[N],son[N],size[N],top[N],id[N],dfn=0;
struct edge{
    int to,next,val;
}data[N<<1];
struct node{
    int mx,add,cov;
}tree[N<<2];
void dfs1(int x){
    size[x]=1;
    for(int i=h[x];i;i=data[i].next){
        int y=data[i].to;
        if(fa[x]==y) continue;
        fa[y]=x;dep[y]=dep[x]+1;p[i>>1]=y;a[y]=data[i].val;
        dfs1(y);size[x]+=size[y];
        if(size[y]>size[son[x]]) son[x]=y;
    }
}
void dfs2(int x,int tp){
    id[x]=++dfn;top[x]=tp;w[dfn]=a[x];
    if(son[x]) dfs2(son[x],tp);
    for(int i=h[x];i;i=data[i].next){
        int y=data[i].to;
        if(y==fa[x]||y==son[x]) continue;
        dfs2(y,y);
    }
}
inline void pushup(int p){
    tree[p].mx=max(tree[p<<1].mx,tree[p<<1|1].mx);
}
inline void pushdown(int p){
    if(!tree[p].cov&&!tree[p].add) return;
    if(tree[p].cov){
        tree[p<<1].cov=tree[p<<1|1].cov=tree[p].cov;
        tree[p<<1].mx=tree[p<<1|1].mx=tree[p].cov;
        tree[p<<1].add=tree[p<<1|1].add=0;
        tree[p].cov=0;
    }
    if(tree[p].add){
        tree[p<<1].add+=tree[p].add;tree[p<<1|1].add+=tree[p].add;
        tree[p<<1].mx+=tree[p].add;tree[p<<1|1].mx+=tree[p].add;
        tree[p].add=0;
    }

}
void build(int p,int l,int r){
    if(l==r){tree[p].mx=w[l];return;}
    int mid=l+r>>1;
    build(p<<1,l,mid);build(p<<1|1,mid+1,r);
    pushup(p);
}
void change(int p,int l,int r,int x,int y,int val){
    if(x<=l&&r<=y){
        tree[p].cov=val;tree[p].mx=val;
        tree[p].add=0;return;
    }
    int mid=l+r>>1;pushdown(p);
    if(x<=mid) change(p<<1,l,mid,x,y,val);
    if(y>mid) change(p<<1|1,mid+1,r,x,y,val);
    pushup(p);
}
void add1(int p,int l,int r,int x,int y,int val){
    if(x<=l&&r<=y){
        tree[p].add+=val;tree[p].mx+=val;return;
    }
    int mid=l+r>>1;pushdown(p);
    if(x<=mid) add1(p<<1,l,mid,x,y,val);
    if(y>mid) add1(p<<1|1,mid+1,r,x,y,val);
    pushup(p);
}
int qmax(int p,int l,int r,int x,int y){
    if(x<=l&&r<=y){return tree[p].mx;}
    int mid=l+r>>1,res=0;pushdown(p);
    if(x<=mid) res=max(res,qmax(p<<1,l,mid,x,y));
    if(y>mid) res=max(res,qmax(p<<1|1,mid+1,r,x,y));
    return res;
}
void dochange(int x,int y,int val){
    while(top[x]!=top[y]){
        if(dep[top[x]]<dep[top[y]]) swap(x,y);
        change(1,1,n,id[top[x]],id[x],val);
        x=fa[top[x]];
    }
    if(id[x]>id[y]) swap(x,y);if(id[x]==id[y]) return;
    change(1,1,n,id[x]+1,id[y],val);
}
void doadd(int x,int y,int val){
    while(top[x]!=top[y]){
        if(dep[top[x]]<dep[top[y]]) swap(x,y);
        add1(1,1,n,id[top[x]],id[x],val);
        x=fa[top[x]];
    }
    if(id[x]>id[y]) swap(x,y);if(id[x]==id[y]) return;
    add1(1,1,n,id[x]+1,id[y],val);
}
int domax(int x,int y){
    int res=0;
    while(top[x]!=top[y]){
        if(dep[top[x]]<dep[top[y]]) swap(x,y);
        res=max(res,qmax(1,1,n,id[top[x]],id[x]));
        x=fa[top[x]];
    }
    if(id[x]>id[y]) swap(x,y);if(id[x]==id[y]) return res;
    return max(res,qmax(1,1,n,id[x]+1,id[y]));
}
int main(){
//  freopen("a.in","r",stdin);
    n=read();
    for(int i=1;i<n;++i){
        int x=read(),y=read(),v=read();
        data[i<<1].to=y;data[i<<1].next=h[x];h[x]=i<<1;data[i<<1].val=v;
        data[i<<1|1].to=x;data[i<<1|1].next=h[y];h[y]=i<<1|1;data[i<<1|1].val=v;
    }
    dep[1]=1;dfs1(1);dfs2(1,1);build(1,1,n);
    while(1){
        char op[10];scanf("%s",op+1);
        if(op[2]=='t') break;int x=read(),y=read();
        if(op[2]=='h') change(1,1,n,id[p[x]],id[p[x]],y);
        if(op[2]=='o') dochange(x,y,read());
        if(op[2]=='d') doadd(x,y,read());
        if(op[2]=='a') printf("%d\n",domax(x,y));
    }
    return 0;
}
【BZOJ 2243】染色 【树链剖分】
skysys的研究小屋
10-28 930
静态查错能力显著提升233，这次3分钟就查出bug#include<cstdio> #include<cstring> #include<cmath> #include<algorithm> #include<iostream> #include<cctype> using namespace std; #define N 100010 #define g() getchar() #define d
【BZOJ 1036】[ZJOI2008]树的统计Count 【树链剖分+线段树】
skysys的研究小屋
10-27 680
裸题.. 开始的代码有个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
树链剖分（边权）
gebixiaofang的博客
10-22 441
#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...
洛谷P4315 月下“毛景树”
蒟蒻的博客
03-22 258
题目描述毛毛虫经过及时的变形，最终逃过的一劫，离开了菜妈的菜园。 毛毛虫经过千山万水，历尽千辛万苦，最后来到了小小的绍兴一中的校园里。爬啊爬~爬啊爬毛毛虫爬到了一颗小小的“毛景树”下面，发现树上长着他最爱吃的毛毛果~ “毛景树”上有N个节点和N-1条树枝，但节点上是没有毛毛果的，毛毛果都是长在树枝上的。但是这棵“毛景树”有着神奇的魔力，他能改变树枝上毛毛果的个数：Change k w：将第k条树枝...
poj 2763 Housewife Wind 边权的树链剖分
TIMELIMITE的专栏
09-08 622
// poj 2763 Housewife Wind 边权的树链剖分 // // 题目意思很清楚,关于边权的树链剖分,首先 // 肯定是先把链剖分好啦,然后就是将边权转化 // 成离根节点较远的点的权值即可.单点更新, // 区间求和,注意,莫要重复计算哟,这题还有需要 // 研究的地方,继续加油吧~~~ #include #include #include #include #defi
[BZOJ2157] 旅游 边权树链剖分
Cabinfever的专栏
11-03 715
对于边权，我们将其赋值到树边的子节点上就好 查询，修改时，只需要在两点都在一条重链时，序号小的点+1即可 （x,y,min,max写混WA了一发，气，另外需要改一改线段树的写法了，又臭又长）/************************************************************** Problem: 2157 User: cabinfever
【树链剖分】【边权】
Vampire
05-20 1772
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
BZOJ 2157 「国家集训队」旅游（树链剖分，线段树，边权转点权）【BZOJ计划】
繁凡さん的博客
09-22 1747
【BZOJ修复计划 #20】BZOJ 2157 旅游 【国家集训队2011】
对LCA、树上倍增、树链剖分（重链剖分&长链剖分）和LCT（Link-Cut Tree）的学习
热门推荐
路人黑的纸巾
10-18 1万+
一篇从浅到深探究一些树上算法的博客
树链剖分_王天懿.ppt
09-14
1. **POJ 3237**：维护边权的修改和路径上边权的取反操作，可以利用树链剖分和线段树联合解决。 2. **BZOJ 3083**：改变路径上点的权值和查询子树最小值，同样可以通过树链剖分实现。 3. **BZOJ 3531**：改变点的...
树链剖分边权版
maze_illusion的博客
08-30 285
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.2763 Housewife Wind ( 边权树链剖分 线段树维护区间和 )
Pengwill's Blog
08-13 479
POJ.2763 Housewife Wind ( 边权树链剖分 线段树维护区间和 )题意分析给出n个点，m个询问，和当前位置pos。 先给出n-1条边，u->v以及边权w。 然后有m个询问，询问分2种： 一是讲第i条边的边权修改为w。 二是询问从当前位置走到点x经过的边权和(下次询问就是从这点开始)。边权的树链剖分，其实和点权的差不多。对于一条边u-v，及其边权w，在建立线段树的时候，将深
树链剖分（spoj375）基于边权
龙崎的专栏
01-10 684
原来以为树链剖分是很高端的数据结构，学习之后才知道，树链剖分思想也不是很难，首先把树分成好多条链，然后结合线段树或者伸展树 SPOJ Problem Set (classical) 375. Query on a tree Problem code: QTREE You are given a tree (an acyclic undirected connected graph)
树链剖分边权 poj 3237
Black__wing的博客
06-19 280
#include <cstdio> #include<string.h> #include<algorithm> #include<iostream> using namespace std; const int M=2e5+100; int f[M]; int d[M]; int siz[M]; int rk[M];//保存树链剖分后，节点编号对...
边权更新 查询路径长度和最大边权 【树链剖分 模板】
lzs_lazy
09-13 804
题意 给n个点的树，有两种操作 op x y ，第一种操作，将第x条边修改权值为y，第二种操作查询x到y的路径长度。今天刚学，说下我目前的理解，树链剖分就是将树上的边按照一种序排列到线段树上，从而进行快速的查询和更新。 对树的拆分，分为轻链和重链，快速的查询多是在重链上，轻链一般还是要一个个走，所以查询的时候，多是将轻链上的点跳到重链上，从而对多个重链来处理达到查询的目的。 【ps 练
bzoj 1984(线段树+树链剖分)
M_AXSSI的博客
05-19 424
1984: 月下“毛景树” Time Limit: 20 Sec  Memory Limit: 64 MB Submit: 1433  Solved: 449 [Submit][Status][Discuss] Description 毛毛虫经过及时的变形，最终逃过的一劫，离开了菜妈的菜园。 毛毛虫经过千山万水，历尽千辛万苦，最后来到了小小的绍兴一中的校园里。爬啊爬~爬啊爬~~毛毛虫
bzoj 1984: 月下“毛景树”
lqybzx的专栏
12-27 803
Description 毛毛虫经过及时的变形，最终逃过的一劫，离开了菜妈的菜园。 毛毛虫经过千山万水，历尽千辛万苦，最后来到了小小的绍兴一中的校园里。爬啊爬~爬啊爬~~毛毛虫爬到了一颗小小的“毛景树”下面，发现树上长着他最爱吃的毛毛果~~~ “毛景树”上有N个节点和N-1条树枝，但节点上是没有毛毛果的，毛毛果都是长在树枝上的。但是这棵“毛景树”有着神奇的魔力，他能改变树枝上毛毛果的个数： 
BZOJ1984: 月下“毛景树”
Oakley
08-15 1119
1984: 月下“毛景树” Time Limit: 20 Sec  Memory Limit: 64 MB Submit: 1583  Solved: 500 [Submit][Status][Discuss] Description 毛毛虫经过及时的变形，最终逃过的一劫，离开了菜妈的菜园。 毛毛虫经过千山万水，历尽千辛万苦，最后来到了小小的绍兴一中的校园里。爬啊爬~爬啊
poj 2763 Housewife Wind（树链剖分---边权化点权）
雪的期许
08-13 456
Housewife Wind Time Limit: 4000MS   Memory Limit: 65536K Total Submissions: 14220   Accepted: 3935 Description After their royal wedding, Jiajia and Wind ...
树链剖分会用的上吗
最新发布
06-04
### 树链剖分的适用场景与使用方法 树链剖分是一种高效的数据结构，用于处理树上的路径查询和修改问题。它通过将树分解为若干条不相交的链来优化复杂度，使得许多原本需要 \(O(n)\) 时间的操作可以在 \(O(\log n)\) 时间内完成[^1]。 #### 1. 树链剖分的核心思想 树链剖分的核心在于将树分割成若干条链，这些链可以拼接成树上的任意路径。常见的树链剖分方法包括重链剖分和长链剖分。其中，重链剖分是最常用的一种方法，其基本原理是：对于每个节点，选择其所有子节点中包含节点数最多的子节点作为重儿子，连接重儿子的边称为重边，由重边构成的链称为重链[^2]。 #### 2. 树链剖分的适用场景 树链剖分适用于以下场景： - **路径查询**：例如，求解树上两点之间的最大值、最小值或和等问题。 - **路径修改**：例如，对树上某条路径上的所有节点进行加法或乘法操作。 - **子树查询**：例如，求解某个节点的子树中的最大值、最小值或和等问题。 - **动态维护**：当树的结构或节点属性发生变化时，树链剖分结合线段树等数据结构可以高效地维护这些变化。 #### 3. 树链剖分的应用方法 以下是树链剖分的基本应用步骤： ```python # 树链剖分的实现示例（Python） from collections import defaultdict, deque class TreeChainDecomposition: def __init__(self, n): self.n = n self.adj = defaultdict(list) self.parent = [0] * (n + 1) self.depth = [0] * (n + 1) self.size = [0] * (n + 1) self.heavy = [0] * (n + 1) self.top = [0] * (n + 1) self.pos = [0] * (n + 1) self.rpos = [0] * (n + 1) self.cnt = 0 def add_edge(self, u, v): self.adj[u].append(v) self.adj[v].append(u) def dfs1(self, u, p): self.parent[u] = p self.size[u] = 1 max_subtree = -1 for v in self.adj[u]: if v != p: self.depth[v] = self.depth[u] + 1 self.dfs1(v, u) self.size[u] += self.size[v] if self.size[v] > max_subtree: max_subtree = self.size[v] self.heavy[u] = v def dfs2(self, u, t): self.top[u] = t self.pos[u] = self.cnt self.rpos[self.cnt] = u self.cnt += 1 if self.heavy[u] != 0: self.dfs2(self.heavy[u], t) for v in self.adj[u]: if v != self.parent[u] and v != self.heavy[u]: self.dfs2(v, v) # 示例：初始化并构建树 n = 5 tree = TreeChainDecomposition(n) edges = [(1, 2), (1, 3), (2, 4), (2, 5)] for u, v in edges: tree.add_edge(u, v) tree.dfs1(1, 0) tree.dfs2(1, 1) ``` 上述代码实现了树链剖分的基本框架，包括深度优先搜索（DFS）和重链划分。 #### 4. 实际应用案例 以 bzoj3252 为例，题目要求在树状结构中求解路径的最大价值和。这种问题可以通过树链剖分结合线段树或树状数组来解决。具体步骤如下： - 使用树链剖分将树划分为若干条链。 - 对每条链建立线段树或其他支持快速区间查询和修改的数据结构。 - 在查询或修改时，将路径拆分为若干条链，并分别在线段树上进行操作[^3]。 #### 5. 注意事项 - 树链剖分的时间复杂度通常为 \(O(n \log n)\)，适合处理大规模数据。 - 在实际应用中，需要根据问题的具体需求选择合适的剖分方式（如重链剖分或长链剖分）。 - 结合其他数据结构（如线段树、树状数组）可以进一步提升效率。 ---
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值