树链剖分笔记_(:з」∠)_（戳）

对于树链剖分，看到大佬纷纷各种躺切内心很是惶恐，于是跪着请教大佬之后把自己的一点感悟发出来以防以后忘了qwq

什么是树链剖分？

指一种对树进行划分的算法，它先通过轻重边剖分将树分为多条链，保证每个点属于且只属于一条链，然后再通过数据结构（树状数组、SBT、SPLAY、线段树等）来维护每一条链

上面的部分感谢百度百科emmmmm…..
所以说这是用来维护树路径的信息的，复杂度为O(logn)，依照我的字面理解是‘树的链剖分’，对一棵树进行链剖分，再套上其他数据结构一起来搞事情。

怎么个剖分方法？

常见的剖分的方法是轻重树链剖分（也叫启发式剖分）

具体步骤是什么？

·第一步是对树进行轻重边的划分。
首先说一下什么叫重边

重边：某个节点x到孩子节点形成的子树中节点数最多的点child之间的边，由定义发现除了叶子节点其他节点只有一条重边
因此定义size[x]为以x为根的子树节点个数，令v为u的儿子中size值最大的节点，那么(u,v)就是重边，其余边为轻边。

·进一步剖分过程分为两次dfs

第一次dfs就是找重边，也就是记录下所有的重边。
程序具体操作：
首先记录深度，更新父亲，初始化儿子数，然后再在向外扩展时更新儿子数，按照定义记录重儿子边

·然后第二次dfs就是连接重边形成重链
具体过程：以根节点为起点，沿着重边向下拓展，拉成重链，不在当前重链上的节点，都以该节点为起点向下重新拉一条重链。
程序具体操作：先记录链顶节点，记录在对应在线段树中的叶节点的左端点 ；再递归重儿子,把他的子孙中的”重”部分的top也置为tot
然后递归轻儿子,将轻儿子的top设为轻儿子自身，它的下一代轻儿子top为下一代轻儿子本身，而重儿子top设为此轻儿子

那就这么完了吗？

这是一般的树链剖分套路
对于本题来讲in函数为插入一点，在处理求和dosum函数时要理解
过程是找同一条链，让更深的往上跳，直到来到了一条链上，然后处理求和

另外数组有点多，不好好看可能有点晕(¦3」∠)_(:з」∠)_

size[]数组，用来保存以x为根的子树节点个数
top[]数组，用来保存当前节点的所在链的顶端节点
son[]数组，用来保存重儿子
dep[]数组，用来保存当前节点的深度
fa[]数组，用来保存当前节点的父亲

可以用二维数组邻接表链式前向星来表示边，听说用邻接表or链式前向星来搞边是比较好的，对于我主要还是对链式前向星比较熟悉emmmmmm

搞完了剖分基本就是套线段树之类数据结构的来进一步实现搞事，这个嘛本蒟蒻需要继续钻研，不敢乱说23333

emm看码思考下？

以codevs 2460 树的统计为例（写得丑不要嫌弃qwq）

附上一份中间没空格的样例输入

4
1 2
2 3
4 1
4 2 1 3
12
QMAX 3 4
QMAX 3 3
QMAX 3 2
QMAX 2 3
QSUM 3 4
QSUM 2 1
CHANGE 1 5
QMAX 3 4
CHANGE 3 6
QMAX 3 4
QMAX 2 4
QSUM 3 4

输出：

4
1
2
2
10
6
5
6
5
16

代码如下：

#include<iostream>
#include<cstdio>
#include<cstring>
#define ls p<<1
#define rs p<<1|1
#define mid (shu[p].l+shu[p].r >>1)
#define RI register int
using namespace std;
const int sz = 300010;
int pos[sz],son[sz],top[sz],size[sz];
int dep[sz],fa[sz],fir[sz],nxt[sz];
int w[sz];
int tot,n,q,cnt,x,y,num;
char ch[15];
struct node{
    int l,r;
    int sum,max;
}shu[sz<<2];
struct ed{
    int f,t;
}l[sz<<1];
inline void read(int &x)
{
    x = 0;bool flag = 0;
    char ch = getchar();
    while(ch < '0' || ch > '9')
    {if(ch == '-')   flag = 1;ch = getchar();}
    while(ch >= '0' && ch <= '9')
    {x = x * 10 + ch - '0';ch = getchar();}
    if(flag)
        x *= -1;
}
inline void add(int f,int t)
{
    l[++tot]=(ed){f,t};
    nxt[tot]=fir[f];
    fir[f]=tot;
}
inline void build(int p,int l,int r)
{
    shu[p].l=l,shu[p].r=r;
    if(l==r)
    {
        shu[p].sum = shu[p].max=0;
        return;
    }
    int midd = l+r>>1;
    build(ls,l,midd);
    build(rs,midd+1,r);
    shu[p].sum=shu[ls].sum+shu[rs].sum;
    shu[p].max=max(shu[ls].max,shu[rs].max);    
}
void dfs1(int k,int f,int d)
{
    dep[k]=d;
    fa[k]=f;
    size[k]=1;
    for(RI i=fir[k];i;i=nxt[i])
    {
        int x=l[i].t;
        if(x==f)
            continue;
        dfs1(x,k,d+1);
        size[k]+=size[x];
        if(!son[k]||size[x]>size[son[k]])
            son[k]=x;
    }
}
void dfs2(int k,int tot)
{
    top[k]=tot;
    pos[k]=++num;
    if(!son[k])
        return;
    dfs2(son[k],tot);
    for(RI i=fir[k];i;i=nxt[i])
    {
        int x=l[i].t;
        if(x!=son[k]&&x!=fa[k])
            dfs2(x,x); 
    }
}
void in(int p,int x,int v)
{
    if(shu[p].l==shu[p].r)
    {
        shu[p].sum=shu[p].max=v;
        return;
    }
    if(x<=mid)
        in(ls,x,v);
    else if(x>mid)
        in(rs,x,v);
    shu[p].sum=shu[ls].sum+shu[rs].sum;
    shu[p].max=max(shu[ls].max,shu[rs].max);
}
int qsum(int p,int l,int r)
{
    if(shu[p].l>=l&&shu[p].r<=r)
        return shu[p].sum;
    int ans=0;
    if(l<=mid)
        ans+=qsum(ls,l,r);
    if(r>mid)
        ans+=qsum(rs,l,r);
    return ans;
}
int qmax(int p,int l,int r)
{
    if(shu[p].l>=l&&shu[p].r<=r)
        return shu[p].max;
    int ans=-10000007;
    if(l<=mid)
        ans=max(ans,qmax(ls,l,r));
    if(r>mid)
        ans=max(ans,qmax(rs,l,r));
    return ans;
}
int dosum(int x,int y)
{
    int ans=0;
    while(top[x]!=top[y])
    {
        if(dep[top[x]]<dep[top[y]])
            swap(x,y);
        ans+=qsum(1,pos[top[x]],pos[x]);
        x=fa[top[x]];
    } 
    if(pos[x]>pos[y])
        swap(x,y);
    ans+=qsum(1,pos[x],pos[y]);
    return ans; 
}
int domax(int x,int y)
{
    int ans=-1e8;
    while(top[x]!=top[y])
    {
        if(dep[top[x]]<dep[top[y]])
            swap(x,y);
        ans=max(ans,qmax(1,pos[top[x]],pos[x]));
        x=fa[top[x]];
    }
    if(pos[x]>pos[y])
        swap(x,y);
    ans=max(ans,qmax(1,pos[x],pos[y]));
    return ans;
}
int main()
{
    read(n);
    for(RI i=1;i<n;i++)
    {
        read(x),read(y);
        add(x,y);
        add(y,x);
    }
    for(RI i=1;i<=n;i++) read(w[i]);
    dfs1(1,0,1);
    dfs2(1,1);
    build(1,1,n);
    for(RI i = 1;i <= n;i ++)
        in(1,pos[i],w[i]);
    read(q);
    while(q--)
    {
        scanf("%s",ch);
        read(x),read(y);
        if(ch[0]=='C')
        {
            w[x]=y;
            in(1,pos[x],y);
        }
        else
        {
            if(ch[1]=='M')
                printf("%d\n",domax(x,y));
            else
                printf("%d\n",dosum(x,y));
        }
    }
    return 0;    
}