树链剖分是解决树上问题的一种常见数据结构,对于树上路径修改及路径信息查询等问题有着较优的复杂度。树链剖分分为两种:重链剖分和长链剖分,通常说的树链剖分指的是重链剖分。
一些名词:
重儿子:每个点的子树中,子树大小(即节点数)最大的子节点(如果有多个节点,任选一个)
轻儿子:除重儿子外的其他子节点
重边:每个节点与其重儿子间的边
轻边:每个节点与其轻儿子间的边
重链:重边连成的链
轻链:轻边连成的链
剖分后的树有一个性质:从根到某一点的路径上轻链、重链的个数都不大于 l o g n logn logn。
树链剖分就是将树中每一个点重新编号,编号的过程用
d
f
s
dfs
dfs来进行,从
1
1
1开始,但是不是随便
d
f
s
dfs
dfs的,对于一个节点
u
u
u,我们总是先进入它的重儿子搜索。进行完重新编号后,树中的任意一条重链上的点的编号一定是连续的。
然后我们可以对树的新编号建立一个线段树来维护一些值。
模版题:
#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstring>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <vector>
#include <string>
#include <algorithm>
#define INF 0x3f3f3f3f
using namespace std;
typedef long long LL;
const int N = 1e5 + 10;
int n, m, w[N];
int tot, id[N], nw[N];
int sz[N], dep[N], top[N], fa[N], son[N];
//sz[i]:子树i的大小 dep[i]:i点的深度
//top[i]:点i所在链的顶点 fa[i]:点i的父节点
//son[i]:点i的重儿子
int idx, head[N], e[N<<1], ne[N<<1];
struct Node
{
int l, r;
LL add, sum;
#define ls (u << 1)
#define rs (u << 1 | 1)
} tr[N * 4];
void add(int u, int v)
{
e[++ idx] = v, ne[idx] = head[u], head[u] = idx;
}
//dfs1可以求出每个点的深度dep,子树大小sz,每个点的父节点fa,每个点的重儿子son
void dfs1(int u, int father, int depth) //当前节点u,父节点fa,当前深度depth
{
dep[u] = depth, fa[u] = father, sz[u] = 1;
for(int i = head[u]; i; i = ne[i])
{
int v = e[i];
if(v == father) continue;
dfs1(v, u, depth + 1);
sz[u] += sz[v];
if(sz[son[u]] < sz[v]) son[u] = v;
}
}
//dfs2可以求出每个点所在链的链顶点top,每个点的新编号id,每个新编号对应的点权nw
void dfs2(int u, int t) //当前的u,u所在链的顶点t
{
id[u] = ++ tot, nw[tot] = w[u], top[u] = t;
if(!son[u]) return ;//叶节点
dfs2(son[u], t); //先递归重儿子
for(int i = head[u]; i; i = ne[i]) //然后在遍历轻儿子
{
int v = e[i];
if(v == fa[u] || v == son[u]) continue;
dfs2(v, v); //轻儿子一定是所在链的链顶
}
}
/*------------------------正常线段树代码-----------------------------*/
void pushup(int u)
{
tr[u].sum = tr[ls].sum + tr[rs].sum;
}
void pushdown(int u)
{
if(!tr[u].add) return ;
LL t = tr[u].add; tr[u].add = 0;
tr[ls].sum += t * (tr[ls].r - tr[ls].l + 1);
tr[rs].sum += t * (tr[rs].r - tr[rs].l + 1);
tr[ls].add += t, tr[rs].add += t;
}
void build(int u, int l, int r)
{
tr[u] = {l, r, 0, nw[r]};
if(l == r) return ;
int mid = l + r >> 1;
build(ls, l, mid), build(rs, mid + 1, r);
pushup(u);
}
void update(int u, int l, int r, int k)
{
if(l <= tr[u].l && tr[u].r <= r)
{
tr[u].add += k;
tr[u].sum += k * (tr[u].r - tr[u].l + 1);
return ;
}
pushdown(u);
int mid = tr[u].l + tr[u].r >> 1;
if(l <= mid) update(ls, l, r, k);
if(r > mid) update(rs, l, r, k);
pushup(u);
}
LL query(int u, int l, int r)
{
if(l <= tr[u].l && tr[u].r <= r) return tr[u].sum;
pushdown(u);
int mid = tr[u].l + tr[u].r >> 1;
LL res = 0;
if(l <= mid) res += query(ls, l, r);
if(r > mid) res += query(rs, l, r);
return res;
}
/*------------------------------------------------------------------*/
void update_path(int u, int v, int k) //将树上u-->v的路径中的所有点加上k
{
while(top[u] != top[v])
{
if(dep[top[u]] < dep[top[v]]) swap(u, v);
update(1, id[top[u]], id[u], k);
u = fa[top[u]];
}
if(dep[u] < dep[v]) swap(u, v);
update(1, id[v], id[u], k);
}
LL query_path(int u, int v) //求树上u-->v的路径中的所有点的权值和
{
LL res = 0;
while(top[u] != top[v])
{
if(dep[top[u]] < dep[top[v]]) swap(u, v);
res += query(1, id[top[u]], id[u]);
u = fa[top[u]];
}
if(dep[u] < dep[v]) swap(u, v);
res += query(1, id[v], id[u]);
return res;
}
void update_tree(int u, int k) //将以u为根的子树中的每一个点都加k
{
update(1, id[u], id[u] + sz[u] - 1, k); //该子树中所有点的新编号一定是连续的一段
}
LL query_tree(int u) //询问以u为根的子树的权值和
{
return query(1, id[u], id[u] + sz[u] - 1);
}
int main()
{
#ifdef LOCAL
freopen("in.in", "r", stdin);
freopen("out.out", "w", stdout);
#endif
scanf("%d", &n);
for(int i = 1; i <= n; i ++) scanf("%d", &w[i]);
for(int i = 1; i < n; i ++)
{
int a, b;
scanf("%d%d", &a, &b);
add(a, b), add(b, a);
}
dfs1(1, -1, 1);
dfs2(1, 1);
build(1, 1, n);
scanf("%d", &m);
while(m --)
{
int opt, u, v, k;
scanf("%d%d", &opt, &u);
if(opt == 1)
{
scanf("%d%d", &v, &k);
update_path(u, v, k);
}
else if(opt == 2)
{
scanf("%d", &k);
update_tree(u, k);
}
else if(opt == 3)
{
scanf("%d", &v);
printf("%lld\n", query_path(u, v));
}
else printf("%lld\n", query_tree(u));
}
return 0;
}
「ZJOI2008」树的统计
#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstring>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <vector>
#include <string>
#include <algorithm>
#define INF 0x3f3f3f3f
using namespace std;
typedef long long LL;
const int N = 3e4 + 10;
int n, m, w[N];
int tot, id[N], nw[N];
int sz[N], dep[N], fa[N], top[N], son[N];
int idx, head[N], e[N<<1], ne[N<<1];
void add(int u, int v)
{
e[++ idx] = v, ne[idx] = head[u], head[u] = idx;
}
void dfs1(int u, int pre, int depth)
{
dep[u] = depth, fa[u] = pre, sz[u] = 1;
for(int i = head[u]; i; i = ne[i])
{
int v = e[i];
if(v == pre) continue;
dfs1(v, u, depth + 1);
sz[u] += sz[v];
if(sz[son[u]] < sz[v]) son[u] = v;
}
}
void dfs2(int u, int t)
{
id[u] = ++ tot, nw[tot] = w[u], top[u] = t;
if(!son[u]) return ;
dfs2(son[u], t);
for(int i = head[u]; i; i = ne[i])
{
int v = e[i];
if(v == fa[u] || v == son[u]) continue;
dfs2(v, v);
}
}
struct Node
{
int l, r;
LL mx, sum;
#define ls (u << 1)
#define rs (u << 1 | 1)
} tr[N * 4];
void pushup(int u)
{
tr[u].mx = max(tr[ls].mx, tr[rs].mx);
tr[u].sum = tr[ls].sum + tr[rs].sum;
}
void build(int u, int l, int r)
{
tr[u] = {l, r, nw[l], nw[l]};
if(l == r) return ;
int mid = l + r >> 1;
build(ls, l, mid), build(rs, mid + 1, r);
pushup(u);
}
void update(int u, int x, int v)
{
if(tr[u].l == tr[u].r)
{
tr[u].mx = tr[u].sum = v;
return ;
}
int mid = tr[u].l + tr[u].r >> 1;
if(x <= mid) update(ls, x, v);
else update(rs, x, v);
pushup(u);
}
Node merge(Node &a, Node &b)
{
return {a.l, b.r, max(a.mx, b.mx), a.sum + b.sum};
}
Node query(int u, int l, int r)
{
if(l <= tr[u].l && tr[u].r <= r) return tr[u];
int mid = tr[u].l + tr[u].r >> 1;
if(r <= mid) return query(ls, l, r);
else if(l > mid) return query(rs, l, r);
else
{
Node left = query(ls, l, r), right = query(rs, l, r);
return merge(left, right);
}
}
Node query_path(int u, int v)
{
Node res = {0, 0, -INF, 0}, t;
while(top[u] != top[v])
{
if(dep[top[u]] < dep[top[v]]) swap(u, v);
t = query(1, id[top[u]], id[u]);
res = merge(res, t);
u = fa[top[u]];
}
if(dep[u] < dep[v]) swap(u, v);
t = query(1, id[v], id[u]);
return merge(res, t);
}
int main()
{
#ifdef LOCAL
freopen("in.in", "r", stdin);
freopen("out.out", "w", stdout);
#endif
scanf("%d", &n);
for(int i = 1; i < n; i ++)
{
int a, b;
scanf("%d%d", &a, &b);
add(a, b), add(b, a);
}
for(int i = 1; i <= n; i ++) scanf("%d", &w[i]);
dfs1(1, -1, 1);
dfs2(1, 1);
build(1, 1, n);
scanf("%d", &m);
while(m --)
{
char str[10];
int u, v;
scanf("%s%d%d", str, &u, &v);
if(str[1] == 'H') update(1, id[u], v);
else
{
Node ans = query_path(u, v);
printf("%d\n", str[1] == 'M' ? ans.mx : ans.sum);
}
}
return 0;
}