树链剖分之重链剖分 详解 题目整理
树链剖分
题目中出现的树链剖分一般分为两种，重链剖分和长链剖分
- 重链剖分：选择子树最大的儿子， 将其归入当前点所在 的同一条重链
- 长链剖分：选择向下能达到的深 度最深的儿子，将其归 入当前点所在的同一 条长链
重剖主要用于维护子树信息和链信息，长剖主要用于维护子树中只与深度有关的信息
- 树链查询：树上前缀 +LCA
- 树链修改：树上差分
- 树链修改 & 树链查询：重链剖分 + 树状数组 | 线段树 |……
重剖
基本概念
- 重子节点：所有子节点中子树大小最大的儿子节点
- 轻子节点：除重儿子之外的所有子节点
- 重边：重子节点和其父节点之间连的边
- 轻边：轻子节点和其父节点之间连的边
- 重链：重边连接而成的链
- d f s dfs dfs序：对树进行深度优先搜索，第一次访问到某个点时对其标号，按标号从小到大排序得到的序列叫 d f s dfs dfs序
子树的 d f s dfs dfs序是连续的
树上的子树修改和子树查询，等价于 d f s dfs dfs序上的区间修改和区间查询
重剖
- 从根开始对树进行深度优先搜索，同时优先搜索重儿子，在重链的每个点上记录每条重链的起点
- 优先搜索重儿子操作使得每条重链在dfs序上是连续的
树划分为轻边和重链
重链上的点dfs序连续，可以数据结构维护
轻边的两端点一定分属某条重链上的点
计算重儿子
- 标记每个点的深度 d e e p [ ] deep[] deep[]
- 标记每个点的父亲 f a [ ] fa[] fa[]
- 标记每个非叶子节点的子树大小(含它自己)
- 标记每个非叶子节点的重儿子编号 s o n [ ] son[] son[]
int deep[maxn], n_size[maxn], fa[maxn], son[maxn];
//depp为节点深度,n_size为节点大小,fa为节点父亲,son为节点的重儿子
void dfs1(int now, int f, int depth) { //now当前节点，f父亲，depth深度
deep[now] = depth; //标记每个点的深度
fa[now] = f; //标记每个点的父亲
n_size[now] = 1; //标记每个非叶子节点的子树大小
for (int i = head[now]; i; i = edge[i].next) {
if (f == edge[i].v)continue; //若为父亲则continue
dfs1(edge[i].v, now, depth + 1); //dfs其儿子
n_size[now] += n_size[edge[i].v]; //把它的儿子数加到它身上
if (n_size[edge[i].v] > n_size[son[now]])//标记每个非叶子节点的重儿子编号
son[now] = edge[i].v;
}
}
标记重链端点
- 标记每个点的新编号
- 赋值每个点的初始值到新编号上(若点有权值)
- 处理每个点所在链的顶端
- 处理每条链
int top[maxn], id[maxn], dfn; //链的顶点,节点的dfs序,dfs序编号
//int wt[maxn], w[maxn]; //新的点权值，原点的权值
void dfs2(int now, int top_node) { //now当前节点，top_node当前链的最顶端的节点
id[now] = ++dfn; //标记每个点的新编号
//wt[dfn] = w[now]; //把每个点的初始值赋到新编号上来
top[now] = top_node; //这个点所在链的顶端
if (!son[now]) return; //如果没有儿子则返回
dfs2(son[now], top_node); //按先处理重儿子，再处理轻儿子的顺序递归处理
for (int i = head[now]; i; i = edge[i].next) {
if (edge[i].v == fa[now] || edge[i].v == son[now])continue;
dfs2(edge[i].v, edge[i].v); //对于每一个轻儿子都有一条从它自己开始的链
}
}
LCA
求x,y的最近公共祖先
深度大的点跳到上一条链
直到两点跳到同一条链为止
int lca(int x, int y) { //x,y为树上两点编号
for (; top[x] != top[y]; x = fa[top[x]])//若不在一个链上,跳转这条链
if (deep[top[x]] < deep[top[y]]) //先跳转深度深的点
swap(x, y);
return deep[x] < deep[y] ? x : y; //在同一条链上返回深度深的点
}
求x到y的第一个点（x为y的祖先）
重复y找祖先的过程，记录上个链的头
若祖先为一个链的尾节点，返回上个链的头
否则返回重儿子即可
int lca2(int x, int y) { //计算y的祖先x向y的第一个点
int t; //记录上个链的顶点
while (top[x] != top[y]) //y向上个链跳转
t = top[y], y = fa[top[y]];
return x == y ? t : son[x]; //x==y则返回上个链的头，反之返回重儿子即可
}
链操作
重复寻找LCA的过程，处理每个链即可
void chain(int x, int y, int val) { //x,y为树上两点编号,val操作
for (; top[x] != top[y]; x = fa[top[x]]) { //若不在一个链上,计算这条链
if (deep[top[x]] < deep[top[y]])swap(x, y); //先计算深度深的点
op(id[top[x]], id[x], val); //调用线段树操作
}
if (deep[x] < deep[y])swap(x, y); //在一条链上
op(id[y], id[x], val); //调用线段树操作
}
边权转点权版
void chain(int x, int y, int val) { //x,y为树上两点编号,val操作
for (; top[x] != top[y]; x = fa[top[x]]) { //若不在一个链上,计算这条链
if (deep[top[x]] < deep[top[y]])swap(x, y); //先计算深度深的点
op(id[top[x]], id[x], val); //调用线段树操作
}
if (deep[x] < deep[y])swap(x, y); //在一条链上
op(id[y]+1, id[x], val); //调用线段树操作,若x==y,线段树不会出问题，不然要调用lca2，抛去lca
}
线段树（友情提供用于区间维护）
LL tree[maxn << 2], lazy[maxn << 2];
void build(int root, int left, int right) { //建树
if (left == right) {
tree[root] = wt[left];
return;
}
int mid = (left + right) >> 1;
build(root << 1, left, mid);
build(root << 1 | 1, mid + 1, right);
tree[root] = (tree[root << 1]+ tree[root << 1 | 1]) % mod;
}
void pushdown(int root, int left, int right) { //懒标记
if (!lazy[root]) return;
int mid = (left + right) >> 1;
tree[root << 1] = (tree[root << 1] + (LL(mid) - left + 1) * lazy[root] % mod) % mod;
lazy[root << 1] = (lazy[root << 1] + lazy[root]) % mod;
tree[root << 1 | 1] = (tree[root << 1 | 1] + (LL(right) - mid) * lazy[root] % mod) % mod;
lazy[root << 1 | 1] = (lazy[root << 1 | 1] + lazy[root]) % mod;
lazy[root] = 0;
}
void update(int root, int left, int right, int stdl, int stdr, LL val) { //区间加
if (stdl <= left && right <= stdr) {
tree[root] = (tree[root] + (LL(right) - left + 1) * val % mod);
lazy[root] = (lazy[root] + val) % mod;
return;
}
pushdown(root, left, right);
int mid = (left + right) >> 1;
if (stdl <= mid) update(root << 1, left, mid, stdl, stdr, val);
if (stdr > mid) update(root << 1 | 1, mid + 1, right, stdl, stdr, val);
tree[root] = (tree[root << 1] + tree[root << 1 | 1]) % mod;
}
LL query(int root, int left, int right, int stdl, int stdr) { //区间求和
LL ans = 0;
if (stdl <= left && right <= stdr)
return tree[root];
pushdown(root, left, right);
int mid = (left + right) >> 1;
if (stdl <= mid) ans = (ans + query(root << 1, left, mid, stdl, stdr)) % mod;
if (stdr > mid) ans = (ans + query(root << 1 | 1, mid + 1, right, stdl, stdr)) % mod;
return ans;
}
常见询问
例题 洛谷 P3384 【模板】树链剖分
例题 BZOJ 树的统计Count
BZOJ 4196: [Noi2015]软件包管理器
代码附于文末
1、 l c a lca lca
调用lca函数即可
2、 x x x到 y y y的链修改，询问
调用上方链操作即可
void chainadd(int x, int y, int val) { //x,y为树上两点编号,val操作
for (; top[x] != top[y]; x = fa[top[x]]) { //若不在一个链上,计算这条链
if (deep[top[x]] < deep[top[y]])swap(x, y); //先计算深度深的点
update(1, 1, n, id[top[x]], id[x], val); //区间加
}
if (deep[x] < deep[y])swap(x, y); //在一条链上
update(1, 1, n, id[y], id[x], val); //区间加
}
LL chainsum(int x, int y) { //x,y为树上两点编号,val操作
LL res = 0;
for (; top[x] != top[y]; x = fa[top[x]]) { //若不在一个链上,计算这条链
if (deep[top[x]] < deep[top[y]])swap(x, y); //先计算深度深的点
res = (res + query(1, 1, n, id[top[x]], id[x])) % mod; //区间求和
}
if (deep[x] < deep[y])swap(x, y); //在一条链上
res = (res + query(1, 1, n, id[y], id[x])) % mod; //区间求和
return res;
}
3、以 x x x为根的子树修改和查询
子树的 d f s dfs dfs序是连续的
树上的子树修改和子树查询，等价于 d f s dfs dfs序上的区间修改和区间查询
update(1, 1, n, id[x], id[x] + n_size[x] - 1, z);//子树修改
query(1, 1, n, id[x], id[x] + n_size[x] - 1); //子树求和
例题
边权转点权
BZOJ1103 大都市meg
题意：
两个操作，1、将某条边由1变成0，2、将1到x求和
思路：
边权转点权
由点权表示该点上一条边的边权
根无点权
修改：将深度大的点变为0
查询：对1到x求和
直接树链剖分+树状数组即可
代码附于文末
BZOJ2157: 旅游
同上题
有几个注意点
1、将根的min设为inf，max设为-inf而不是0
2、求链的操作时，lca的权值不能加进去
代码附于文末
POJ2763 Housewife Wind
题意：
两个操作： 1 x 1 x 1x求s到x的路径和并将s变成x 2 x w 2 x w 2xw将x号边变成w
思路：
边权转点权的裸题
代码附于文末
换根操作
BZOJ3083 遥远的国度
题意：
3个操作： 1 x 1 x 1x将根换成x, 2 x y v 2 x y v 2xyv将 x − y x-y x−y变成v， 3 x 3 x 3x求x的子树的最小值
思路：
换根
如果当前数据指定的根在查询的子树内
则查询操作变为查询根所在分支的子树外的点 (调用 lca2)
可以由两个区间（ 1 − i d [ x ] − 1 1-id[x]-1 1−id[x]−1和 i d [ x ] + s i z e [ x ] − n id[x]+size[x]-n id[x]+size[x]−n）最小值合并得到
如果根在子树外，直接查询子树即可
代码附于文末
链合并有方向性
HDU5893 List wants to travel
题意:
2个操作： C h a n g e x y z Change x y z Changexyz将x到y的链变成z， Q u e r y x y Query x y Queryxy求x到y的链上的不同的连续数的个数，比如 11221 11221 11221有三个
思路：
边权转点权
注意剖去lca
链合并带有方向性
int chain_query(int x, int y) {
int prex = -1, prey = -1, res = 0; //记录两个点的前端点
Tree T;
for (; top[x] != top[y]; x = fa[top[x]]) {
if (deep[top[x]] < deep[top[y]]) {
swap(x, y);
swap(prex, prey);
}
T = query(1, 1, n, id[top[x]], id[x]);
res += T.data;
if (T.suf == prex)res--;
prex = T.pre;
}
if (deep[x] < deep[y]) {
swap(x, y);
swap(prex, prey);
}
if (x == y) { //特判lca为重链最后一个点时
if (prex == prey)res--;
return res;
}
T = query(1, 1, n, id[y] + 1, id[x]);
res += T.data;
if (prex == T.suf)res--;
if (prey == T.pre)res--;
return res;
}
完整模板
#include 例题代码
洛谷 P3384 【模板】树链剖分
#include 树的统计Count
#include [Noi2015]软件包管理器
#include 大都市meg
#include 2157: 旅游
#include Housewife Wind
#include 遥远的国度
#include List wants to travel代码
#include