树链剖分模板（基于点权，基于边权）

树链剖分是数据结构在树上的推广，其实就是把树hash到几段连续的区间，然后用其它数据结构进行维护，相当于对树进行一个预处理
dfs1（）求出fa,deep,size,son
dfs2（）求出top,p

注意：重编号后，要注意编号区间是多少
关键数组：
int deep[maxn];
int size[maxn];
int fa[maxn];
int p[maxn];
int son[maxn];
int fp[maxn];
int top[maxn];

树链剖分 分为基于点权，基于边权
基于点权(hdu3966)，给树上的点重新编号，p[u]表示u对应的位置
基于边权（spoj375），给树上的边重新编号，p[u]表示u与其父亲节点的连边的位置，则根结点与其父亲节点的连边是不能用的

const int maxn=10010;
using namespace std;

/*-----------------------------树链剖分---------------------*/
struct node{
    int v,next;
}edges[maxn<<1];int tot,head[maxn],n;
inline void addedge(int u,int v){//邻接表 记录边
    edges[tot].next=head[u];
    edges[tot].v=v;
    head[u]=tot++;
}
int deep[maxn],size[maxn],top[maxn],fa[maxn],p[maxn],son[maxn],fp[maxn];
//深度，结点数，重链的顶端结点，父亲节点，v与其父亲节点的连边在线段树中的位置(v所在的位置)，重儿子，与p数组相反
int pos;
void Init(){
    memset(son,-1,sizeof(son));
    memset(head,-1,sizeof(head));
    tot=pos=0;
}
void dfs1(int u,int pre,int d){//第一遍dfs求出fa，deep，size，son
    deep[u]=d;
    fa[u]=pre;
    size[u]=1;
    for(int i=head[u];i!=-1;i=edges[i].next){
        int v=edges[i].v;
        if(v!=pre){
            dfs1(v,u,d+1);
            size[u]+=size[v];
            if(son[u]==-1||size[son[u]]<size[v]) son[u]=v;
        }
    }
}
void getpos(int u,int sp){//第二遍dfs求出top和p
    top[u]=sp;
    p[u]=pos++;
    fp[p[u]]=u;
    if(son[u]==-1) return ;
    getpos(son[u],sp);
    for(int i=head[u];i!=-1;i=edges[i].next){
        int v=edges[i].v;
        if(v!=son[u]&&v!=fa[u]) getpos(v,v);
    }
}

修改：
每次选择深度大的重链进行修改，然后将u提到LCA，直到f1==f2
。
当f1=f2后，说明u，v在同一条链上：
1.当基于点权时，即使u==v，也要将路径(u,v)上的每个点进行修改，因为每个点都代表树上的一个编号
2.当基于边权时，将路径(son[u],v)上的边进行修改，因为每个点v的位置表示v到其父节点连边的编号

基于点权：

void change(int u,int v,int val){
    int f1=top[u],f2=top[v];
    while(f1!=f2){
        if(deep[f1]<deep[f2]){
            swap(f1,f2);
            swap(u,v);
        }
        add(p[f1],val);
        add(p[u]+1,-val);
        u=fa[f1];f1=top[u];
    }
    //没有（u==v)的特判
    if(deep[u]>deep[v]) swap(u,v);
    add(p[u],val);
    add(p[v]+1,-val);
}

基于边权：

int find(int u,int v){
    int f1=top[u],f2=top[v];
    int ans=0;
    while(f1!=f2){
        if(dep[f1]<dep[f2]){
            swap(f1,f2);
            swap(u,v);
        }
        ans=max(ans,query(p[f1],p[u],1,pos-1,1));
        u=fa[f1];f1=top[u];
    }
    if(u==v) return ans;//有关于u==v的特判
    if(dep[u]>dep[v]) swap(u,v);
    return max(ans,query(p[son[u]],p[v],1,pos-1,1));
}