树链剖分之轻重链讲解

　　首先我们有一颗树每个点（或者边）有权值，我们要做的就是询问两个点之间路径上各点（边）权值的最大、最小，权值和（就是线段树能干的），然后我们还要支持在线更改任意节点（边）的权值。

　　我们要做的是轻重链剖分，首先我们看几个定义

　　size：和SBT里的一样，size[i]为以该点为根节点的子树一共有几个节点。

　　重儿子：一个节点当不为叶子节点的时候有且只有一个重儿子，重儿子为该点的儿子中size最大的，有多个最大时任选一个。

　　重链：由根节点开始，每个点每次都访问自己的重儿子，一直访问到叶子节点，就组成了一条重链

　　那么对于一个点的非重儿子来说，以他为根节点，可以重新访问出一条重链

　　如图所示，用红色的线画出的为重链，其中6号点自己为一条重链，那么对于每条重链，我们需要记下他的顶标top，就是该重链中深度最小的节点的标号

　　比如链1-3-4-9-10，的top为1，链2-8的top为2。

　　重链几个明显的性质就是互不重合且所有重链覆盖所有点，重链之间由一条不在重链上的边（我们称作轻边）连接，然后对于每一条重链来说，我们定义他的深度，顶标为根节点的重链的深度为1，顶标的父亲在深度为x的重链上，那么该重链深度为x+1，如图链1-3-4-9-10的深度为1，链2-8，链5-7的深度为2，链6的深度为3。 

那么我们首先DFS，可以求出每个点的size，然后再深搜一遍可得到每个点的top，和处理出每一条链

procedure make(x,t,depth:longint);//x代表当前节点，t代表当前重链的顶标，detph代表该重链的深度

var

begin

    if max_son[x]<>0 then make(max_son,top,depth);

    q:=last[x];

    while q<>0 do

    begin

        p:=other[q];

        if (not flag[p]) and (p<>max_son[x]) then

        begin

            flag[p]:=true;

            make(p,p,depth+1);

        end;

        q:=pre[q];

    end;

end.

 

　　那么我们现在有了所有的重链，覆盖每一个点，然后我们要处理的问题是两点之间的最值等问题。

　　是不是有些像线段树，假设我们需要求一条重链上的最大值，那么我们需要将重链存进线段树，且重链上的所有点的编号是连续的（区间），那么我们要对所有的点以深搜序重新编号（make的时候顺便搞一下就好了），那么我们可以用线段树来存树上点的值（边儿的也一样，可以将边下放到点），这样对于在同一条重链上的点我们就可以在logn的时间里求出值了，然后对于不同链上的点，我们先给他们升到同一深度上的链，同时更新答案，然后做就好了（有点类似于倍增，就是今年noip Day1 T3，其实内道题用

树链剖分也行，应该早点学啊啊啊啊）至于每个点的权值修改就完全是线段树的事儿了。

 第一次写，代码不是很好

//By BLADEVIL
type
    rec                 =record
        sum, max        :longint;
        left, right     :longint;
    end;
 
var
    n                   :longint;
    pre, other          :array[0..60010] of longint;
    last, key           :array[0..30010] of longint;
    l                   :longint;
    father, size        :array[0..30010] of longint;
    flag                :array[0..30010] of boolean;
    max_son             :array[0..30010] of longint;
    tot                 :longint;
    num                 :array[0..30010] of longint;
    dep, top            :array[0..30010] of longint;
    t                   :array[0..200010] of rec;
    a                   :array[0..30010] of longint;
     
function max(a,b:longint):longint;
begin
    if a>b then max:=a else max:=b;
end;
 
procedure swap(var a,b:longint);
var
    c                   :longint;
begin
    c:=a; a:=b; b:=c;
end;
     
procedure connect(x,y:longint);
begin
    inc(l);
    pre[l]:=last[x];
    last[x]:=l;
    other[l]:=y;
end;
     
procedure dfs(x:longint);
var
    p, q                :longint;
     
begin
    q:=last[x];
    size[x]:=1;
    while q<>0 do
    begin
        p:=other[q];
        if not flag[p] then
        begin
            father[p]:=x;
            flag[p]:=true;
            dfs(p);
            inc(size[x],size[p]);
            if size[max_son[x]]<size[p] then max_son[x]:=p;
        end;
        q:=pre[q];
    end;
end;
     
procedure make(x,t,depth:longint);
var
    q, p                :longint;
begin
    inc(tot);
    num[x]:=tot;
    a[tot]:=key[x];
    top[x]:=t;
    dep[x]:=depth;
    if max_son[x]<>0 then
    begin
        flag[max_son[x]]:=true;
        make(max_son[x],t,depth);
    end;
    q:=last[x];
    while q<>0 do
    begin
        p:=other[q];
        if (not flag[p]) and (p<>max_son[x]) then
        begin
            flag[p]:=true;
            make(p,p,depth+1);
        end;
        q:=pre[q];
    end;
end;
     
procedure build(x,l,r:longint);
var
    mid                 :longint;
begin
    t[x].left:=l; t[x].right:=r;
    if l=r then
    begin
        t[x].sum:=a[l];
        t[x].max:=a[l];
        exit;
    end;
    mid:=(r+l) div 2;
    build(2*x,l,mid); build(2*x+1,mid+1,r);
    t[x].sum:=t[x*2].sum+t[x*2+1].sum;
    t[x].max:=max(t[x*2].max,t[x*2+1].max);
end;
     
function get_max(x,ll,rr:longint):longint;
var
    mid                 :longint;
begin
    if (t[x].left=ll) and (t[x].right=rr) then
    begin
        get_max:=t[x].max;
        exit;
    end;
    with t[x] do mid:=(left+right) div 2;
    if mid>=rr then get_max:=get_max(x*2,ll,rr) else
    if mid<ll then get_max:=get_max(x*2+1,ll,rr) else
    get_max:=max(get_max(x*2,ll,mid),get_max(x*2+1,mid+1,rr));
end;
 
function get_sum(x,ll,rr:longint):longint;
var
    mid                 :longint;
begin
    get_sum:=0;
    if (t[x].left=ll) and (t[x].right=rr) then
    begin
        get_sum:=t[x].sum;
        exit;
    end;
    with t[x] do mid:=(left+right) div 2;
    if mid>=rr then get_sum:=get_sum(x*2,ll,rr) else
    if mid<ll then get_sum:=get_sum(x*2+1,ll,rr) else
    get_sum:=get_sum(x*2,ll,mid)+get_sum(x*2+1,mid+1,rr);
end;
 
procedure change(x,u,v:longint);
var
    mid                 :longint;
begin
    if (t[x].left=u) and (t[x].right=u) then
    begin
        t[x].sum:=v;
        t[x].max:=v;
        exit;
    end;
    with t[x] do mid:=(right+left) div 2;
    if u>mid then change(x*2+1,u,v) else change(x*2,u,v);
    t[x].sum:=t[x*2].sum+t[x*2+1].sum;
    t[x].max:=max(t[x*2].max,t[x*2+1].max);
end;
     
procedure init;
var
    i                   :longint;
    x, y                :longint;  
begin
    read(n);
    for i:=1 to n-1 do
    begin
        read(x,y);
        connect(x,y);
        connect(y,x);
    end;
    for i:=1 to n do read(key[i]);
    flag[1]:=true;
    dfs(1);
    fillchar(flag,sizeof(flag),false);
    flag[1]:=true;
    make(1,1,1);
    build(1,1,n);
end;
 
procedure query_max(x,y:longint);
var
    ans                 :longint;
begin
    ans:=-maxlongint div 10;
    if dep[x]>dep[y] then swap(x,y);
    while dep[x]<dep[y] do
    begin
        ans:=max(ans,get_max(1,num[top[y]],num[y]));
        y:=father[top[y]];
    end;
    while top[x]<>top[y] do
    begin
        ans:=max(ans,get_max(1,num[top[x]],num[x]));
        ans:=max(ans,get_max(1,num[top[y]],num[y]));
        x:=father[top[x]];
        y:=father[top[y]];
    end;
    x:=num[x]; y:=num[y];
    if x>y then swap(x,y);
    ans:=max(ans,get_max(1,x,y));
    writeln(ans);
end;
 
procedure query_sum(x,y:longint);
var
    ans                 :longint;
begin
    ans:=0;
    if dep[x]>dep[y] then swap(x,y);
    while dep[x]<dep[y] do
    begin
        inc(ans,get_sum(1,num[top[y]],num[y]));
        y:=father[top[y]];
    end;
    while top[x]<>top[y] do
    begin
        inc(ans,get_sum(1,num[top[x]],num[x]));
        inc(ans,get_sum(1,num[top[y]],num[y]));
        x:=father[top[x]];
        y:=father[top[y]];
    end;
    x:=num[x]; y:=num[y];
    if x>y then swap(x,y);
    inc(ans,get_sum(1,x,y));
    writeln(ans);
end;
 
procedure main;
var
    i                   :longint;
    m                   :longint;
    s                   :ansistring;
    c                   :char;
    x, y                :longint;
     
begin
    readln(m);
    for i:=1 to m do
    begin
        c:='w';
        s:='';
        while c<>' ' do
        begin
            read(c);
            s:=s+c;
        end;
        readln(x,y);
        if s[2]='M' then
            query_max(x,y) else
        if s[2]='S' then
            query_sum(x,y) else
            change(1,num[x],y);
    end;
end;
     
     
begin
    init;
    main;
end.