树链剖分模板
啃了好久，终于把树链剖分给啃下来了
前置知识：dfs序，lca，线段树等
算法思想：把树拆成一条一条的链，然后用数据结构维护。
首先定义几个概念：
- 子树大小：以某一节点为根节点的子树中节点的总数，包括该点。
- 重节点：在某一节点的所有子节点中，子树大小最大的节点。
- 轻节点：不是重儿子的节点。特殊的，根节点是轻节点。
- 重链：重节点依次相连形成的链。
具体实现：以luogu3384 【模板】树链剖分 为例
1.dfs1
这个dfs要处理这些事情：
- 每个节点的深度 d e p dep dep
- 每个节点的父亲 f a fa fa
- 每个节点的子树大小 s i z e size size
- 每个节点的重儿子节点 s o n son son
void dfs1(int u, int f, int d){
dep[u] = d, fa[u] = f, size[u] = 1, son[u] = 0;
for(int i = fir[u]; i != -1; i = nxt[i]){
int v = to[i];
if(v == f) continue;
dfs1(v, u, d + 1);
size[u] += size[v];
if(size[v] > size[son[u]]) son[u] = v;
}
}
2.dfs2
这个dfs要做这些事情：
- dfs序。因为要用数据结构维护每条链，需要让重链上的每一个节点的编号 d f n dfn dfn连续。相应的，还要处理出每个编号所对应的节点 i d id id。
- 该节点所在重链链头top。
void dfs2(int u, int topf){
dfn[u] = ++num, id[num] = u, top[u] = topf;
if(!son[u]) return; dfs2(son[u], topf);
for(int i = fir[u]; i != -1; i = nxt[i]){
int v = to[i];
if(v != son[u] && v != fa[u]) dfs2(v, v);
}
}
轻重链划分后，就可以证明复杂度了（以下省略1w字）
也可以看这里
3.线段树
维护的数据结构我们用线段树来解决。
你可以想象，轻链和重链都按照dfs一条一条地躺在了一条线上，这时突然有个线段树跳出来说：我来维护他们！ 太逗了
事实上dfs序有许多优秀的性质。比如，一颗子树里的dfs序总是连续的，这意味着维护子树就可以转化为维护区间；同理，维护重链也可以转换成维护区间了。that’s good
int val[MAXN << 2], tag[MAXN << 2];
#define mid ((l + r) >> 1)
inline void Pushup(int u){
val[u] = (val[u << 1] + val[u << 1 | 1]) % p;
}
inline void Pushdown(int u, int l, int r){
if(tag[u]){
val[u << 1] = (val[u << 1] + (l - mid + 1) * tag[u]) % p;
val[u << 1 | 1] = (val[u << 1 | 1] + (r - mid) * tag[u]) % p;
tag[u] = 0;
}
}
inline void Build(int u, int l, int r){
if(l == r){val[u] = w[id[l]] % p; return;}
Build(u << 1, l, mid); Build(u << 1 | 1, mid + 1, r);
Pushup(u);
}
inline void Modify(int u, int l, int r, int L, int R, int k){
if(l >= L && r <= R){val[u] = (val[u] + (r - l + 1) * k) % p, tag[u] = (tag[u] + k) % p; return;}
Pushdown(u, l, r);
if(L <= mid) Modify(u << 1, l, mid, L, R, k);
if(R > mid) Modify(u << 1 | 1, mid + 1, r, L, R, k);
Pushup(u);
}
inline int Query(int u, int l, int r, int L, int R){
if(l >= L && r <= R) return val[u];
Pushdown(u, l, r); int sum = 0;
if(L <= mid) sum = (sum + Query(u << 1, l, mid, L, R)) % p;
if(R > mid) sum = (sum + Query(u << 1 | 1, mid + 1, r, L, R)) % p;
return sum;
}
#undef mid
要注意的一点是建树时取的初值是 w [ i d [ u ] ] w[id[u]] w[id[u]]。
四个操作
1.修改路径
类似于求lca的思想，两个点向上跳，每跳一条链就对这条链进行修改，最后跳到同一条链的时候修改两点之间的部分。
inline void Path_Add(int x, int y, int k){
while(top[x] != top[y]){
if(dep[top[x]] < dep[top[y]]) swap(x, y); //x向上跳
Modify(1, 1, n, dfn[top[x]], dfn[x], k);
x = fa[top[x]];
}
if(dep[x] > dep[y]) swap(x, y);
Modify(1, 1, n, dfn[x], dfn[y], k);
}
2.查询路径
与修改路径差不多，不同的是把修改换成了统计答案。
inline int Path_Query(int x, int y){
int sum = 0;
while(top[x] != top[y]){
if(dep[top[x]] < dep[top[y]]) swap(x, y);
sum = (sum + Query(1, 1, n, dfn[top[x]], dfn[x])) % p;
x = fa[top[x]];
}
if(dep[x] > dep[y]) swap(x, y);
sum = (sum + Query(1, 1, n, dfn[x], dfn[y])) % p;
return sum;
}
3.修改子树
前面我们说过一颗子树里的dfs序总是连续的，具体就是从 d f n [ i ] dfn[i] dfn[i]到 d f n [ i ] + s i z e [ i ] − 1 dfn[i]+size[i]-1 dfn[i]+size[i]−1的区间。
inline void Subtree_Add(int x, int k){
Modify(1, 1, n, dfn[x], dfn[x] + size[x] - 1, k);
}
4.查询子树
同修改子树。
inline int Subtree_Query(int x){
return Query(1, 1, n, dfn[x], dfn[x] + size[x] - 1);
}
全部代码：
#includetips:写完之后发现还多简单的