HYSBZ1036-树链剖分-点权

树链剖分，点权，单点更改，路径查询。学树链剖分下面这个博文不错

http://blog.csdn.net/y990041769/article/details/40348013

线段树必须写的很熟练才行。注意负数

#include <cstdio>
#include <vector>
#include <algorithm>

using namespace std;

const int maxn = 3e4+10;
const int INF = 0x3f3f3f3f;

/////////////////////////////////////
int topw;
int son[maxn],top[maxn],fa[maxn],siz[maxn],id[maxn],dep[maxn];
int val[maxn],pre_val[maxn];

vector<int> G[maxn];

void dfs_1(int u,int f,int d)
{
    son[u] = 0;
    dep[u] = d;
    fa[u]  = f;
    siz[u] = 1;
    for(int i=0;i<G[u].size();i++)
    {
        int v = G[u][i];
        if(v == f) continue;
        dfs_1(v,u,d+1);
        siz[u] += siz[v];
        if(siz[son[u]] < siz[v])
        {
            son[u] = v;
        }
    }
}

void dfs_2(int u,int tp)
{
    top[u] = tp;
    id[u] = ++topw;
    if(son[u]) dfs_2(son[u],tp);
    for(int i=0;i<G[u].size();i++)
    {
        int v = G[u][i];
        if(v == fa[u] || v == son[u]) continue;
        dfs_2(v,v);
    }
}

////////////////////////////////////
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
#define root 1,topw,1

int sum[maxn<<2];
int mx[maxn<<2];

void push_up(int rt)
{
    sum[rt] = sum[rt<<1]+sum[rt<<1|1];
    mx[rt] = max(mx[rt<<1],mx[rt<<1|1]);
}

void build(int l,int r,int rt)
{
    sum[rt] = 0;
    mx[rt] = 0;
    if(l == r)
    {
        sum[rt] = val[l];
        mx[rt] = val[l];
        return ;
    }
    int m = (l+r)>>1;
    build(lson);
    build(rson);
    push_up(rt);
}

void update(int pos,int add,int l,int r,int rt)
{
    if(l == r)
    {
        sum[rt] = add;
        mx[rt] = add;
        return ;
    }
    int m = (l+r)>>1;
    if(pos <= m) update(pos,add,lson);
    else         update(pos,add,rson);
    push_up(rt);
}

int query_sum(int L,int R,int l,int r,int rt)
{
    if(L <= l && R >= r)
    {
        return sum[rt];
    }
    int m = (l+r)>>1 , ans = 0;
    if(L <= m) ans += query_sum(L,R,lson);
    if(R >  m) ans += query_sum(L,R,rson);
    return ans;
}

int query_max(int L,int R,int l,int r,int rt)
{
    if(L <= l && R >= r)
    {
        //printf("[%d,%d] rt:%d mx:%d
",l,r,rt,mx[rt]);
        return mx[rt];
    }
    int m = (l+r)>>1 , ans = -INF;
    if(L <= m) ans = max(ans,query_max(L,R,lson));
    if(R >  m) ans = max(ans,query_max(L,R,rson));
    return ans;
}

int Find_sum(int u,int v)
{
    int fu = top[u],fv = top[v];
    int ans = 0;
    while(fu != fv)
    {
        //printf("ans:%d %d %d %d %d
",ans,u,fu,v,fv);
        if(dep[fu] < dep[fv])
        {
            swap(u,v);
            swap(fu,fv);
        }
        ans += query_sum(id[fu],id[u],root);
        u = fa[fu];
        fu = top[u];
    }
    if(u == v)
    {
        return ans+query_sum(id[u],id[v],root);
    }
    else{
        if(dep[u] < dep[v]) swap(u,v);
        return ans+query_sum(id[v],id[u],root);
    }
}

int Find_max(int u,int v)
{
    int fu = top[u],fv = top[v];
    int ans = -INF;
    while(fu != fv)
    {
        if(dep[fu] < dep[fv])
        {
            swap(u,v);
            swap(fu,fv);
        }
        //printf("ans:%d %d %d %d %d
",ans,u,fu,v,fv);
        //printf("q:%d
",query_max(id[fu],id[u],root));
        ans = max(ans,query_max(id[fu],id[u],root));
        u = fa[fu];
        fu = top[u];
    }
    if(u == v)
    {
        return max(ans,query_max(id[u],id[v],root));
    }
    else{
        if(dep[u] < dep[v]) swap(u,v);
        return max(ans,query_max(id[v],id[u],root));
    }
}

//////////////////////////////////////////

int N,Q;
int main()
{
    freopen("input.in","r",stdin);
    while(~scanf("%d",&N))
    {
        for(int i=1,u,v;i<N;i++)
        {
            scanf("%d%d",&u,&v);
            G[u].push_back(v);
            G[v].push_back(u);
        }
        for(int i=1;i<=N;i++) scanf("%d",&pre_val[i]);
        topw = 0;
        dfs_1(1,0,1);
        dfs_2(1,1);
        for(int i=1;i<=N;i++) val[id[i]] = pre_val[i];
        build(root);

        scanf("%d",&Q);
        char op[10];
        int a,b;
        while(Q--)
        {
            scanf("%s%d%d",op,&a,&b);
            if(op[0] == 'Q')
            {
                if(op[1] == 'M')
                {
                    printf("%d
",Find_max(a,b));
                }else
                {
                    printf("%d
",Find_sum(a,b));
                }
            }else
            {
                update(id[a],b,root);
            }
        }
        for(int i=0;i<=N;i++) G[i].clear();
    }
}