树链剖分详解

树链剖分定义

只是把一棵树拆成链来处理而已，即将树上的某些段一起通过数据结构优化进行处理来降低复杂度。

树链剖分相关定义

1. 重儿子：$ve[v]$为$u$的子节点中$ve$值最大的，那么$v$就是$u$的重儿子(将子树中最长的那一条链一起处理来降低复杂度)。
2. 轻儿子：$u$除了重儿子的其它子节点。
3. 重边：点$u$与其重儿子的连边。
4. 轻边：点$u$与其轻儿子的连边。
5. 重链：由重边连成的路径。
6. 轻链：轻边。

树链剖分基本性质

1. 如果$(v,u)$为轻边，则$\color{red}{ve[u] \times 2 < ve[v]}$;
2. 从根到某一点的路径上轻链、重链的个数都不大于$logn$。

树链剖分独特之处

主要针对路径进行处理，我们平时处理一颗树的路径的方案一般就是求解$LCA$的各类算法，在线ST，离线tarjan，以及LCA在线倍增法，其实LCA在线倍增法在求解路径方面已经颇为让人满意了，$O(nlogn)$构建，$O(logn)$进行查询，比如一般的求解路径上的最大边权，点权之类的一般LCA倍增法都可以解决，如果再离线一下，或许复杂度更低。

但是树链剖分的独特之处就是可以对路径进行修改，一般结合线段树进行处理，查询更新的复杂度就是$O(logn)$，这是LCA在线倍增所不能做到的。

树链剖分理解

拿求解一条路径上的最大值做例子，树链剖分的思想就是，先对路径进行预处理，将路径上的数据分为几段，然后再对这几段求最大值，有点像分桶法。

看下图：

比如我们要求解从顶点$11$到顶点$14$路径上边权的最大值，我们可以求出$\color{black}{1-4-9-13-14}$这条路径上的最大值$s1$，然后求出$\color{blue}{1-2}$路径上的最大值$s2$,然后再求出$\color{black}{2-6-11}$路径上的最大值$s3$。然后我们再求解$max(s1,s2,s3)$的值就可以得到结果$[$黑色的路径表示图中黑色的路径，代表着重儿子，蓝色的则是代表着不是重儿子的路径$]$

从图上我们可以看出，重儿子所在的路径是子树中路径最长的，这也是为什么重儿子的定义是子树中节点最多的子节点，然后我们也发现黑色的路径上的蓝色编号是连续的，这是为了将这个长的路径保存在一段连续的区间，那么我就可以了对这块连续区间进行操作了。
也许大家已经想到了这样规定的好处，因为越长的，我就一起处理，效率自然是越高了，重儿子就是这么规定而来的。

然后我们对于区间求最值有很多方法，线段树一般就是最优的。

相关数组定义

$deep[u] :$ 来保存当前节点$u$的深度

$fa[u] :$ 用来保存当前节点$u$的父亲

$ve[u] :$ 用来保存以$u$为根的子树节点个数

$son[u] :$ 用来保存当前节点$u$的重儿子

$top[u] :$ 用来保存当前节点$u$的所在链的顶端节点

$p[u] :$ 用来保存当前节点$u$在线段树中的位置

$fp[] :$用来保存线段树相应位置保存的是当前哪个节点

模板代码dfs1

void dfs1(int u, int pre, int d) {
    deep[u] = d;//深度
    fa[u] = pre;//父亲
    ve[u] = 1;//节点个数
    son[u] = -1;//重儿子
    for(int i = Head[u]; ~i; i = E[i].nxt) {
        int v = E[i].v;
        if(v == pre) continue;
        dfs1(v, u, d + 1);
        ve[u] += ve[v];
        if(son[u] == -1 || ve[v] > ve[son[u]]) {//得到重儿子
            son[u] = v;
        }
    }
}

第一个$dfs1$是为了找重边，记录下所有的重边以及相关关系

模板代码dfs2

void dfs2(int u, int sp) {
    top[u] = sp;
    p[u] = ++ sz;
    fp[p[u]] = u;
    if(son[u] == -1) return;
    dfs2(son[u], sp);
    for(int i = Head[u]; ~i; i = E[i].nxt) {
        int v = E[i].v;
        if(v == son[u] || v == fa[u]) continue;
        dfs2(v, v);
    }
}

第二个dfs2就是为了连接重边形成重链，即将这条长路径给连接起来，具体步骤：以根节点为起点，沿着重边向下拓展，拉成重链，不在当前重链上的节点，都以该节点为起点向下重新拉一条重链。

到此，树链剖分部分完毕，构造的每条重链相当于一段连续的区间，然后就是用数据结构处理数据$[$一般是线段树处理$]$。

如何沿着路径进行处理（以查找最大值为例）

步骤跟在求解$11$到$14$的最大值一样。

int find(int u, int v)  {
    int f1 = top[u], f2 = top[v];
    int tmp = 0;
    while(f1 != f2)  {
        if(deep[f1] < deep[f2])   {
            swap(f1, f2);
            swap(u, v);
        }
        tmp = max(tmp, query(1, p[f1], p[u]));
        u = fa[f1];
        f1 = top[u];
    }
    if(u == v)return tmp;
    if(deep[u] > deep[v]) swap(u, v);
    return max(tmp, query(1, p[son[u]], p[v]));
}

分析：

1. 如果u与v在同一条重链上，那么就直接修改了，因为他们是连续的
2. 如果不在一条重链上，则往一条重链上靠拢，然后就会编程一条重链

---

$\color{red}{[}$有些地方不一定说得很清楚，希望大家指出，谢谢！$\color{red}{]}$