bzoj 1036: [ZJOI2008]树的统计Count

题目链接：http://www.lydsy.com/JudgeOnline/problem.php?id=1036

解：树链剖分基础题

对于线性表，我们可以通过线段树、树状数组等数据结构成段修改成段查询，如果想要在树上成段修改查询，我们就需要进行树剖

树剖的大体思路是把树拆成链然后以一定次序放在线性表上，然后利用各种数据结构处理线性表

比如处理树上两点u、v之间的路径，我们要知道这条路径与之前拆分的哪些链相交，然后查询线性表上相交部分

那么时间复杂度为=路径与拆分链相交数*数据结构处理每条链时间

可以有各种拆分链方法，目前最好的一种是轻重链拆分，拆分后保证任意路径穿过拆分链数为log(n)

树剖学习推荐博客：http://blog.sina.com.cn/s/blog_6974c8b20100zc61.html

习题推荐：http://acm.hust.edu.cn/vjudge/contest/view.action?cid=28982#overview

/*
 * Problem:  
 * Author:  SHJWUDP
 * Created Time:  2015/6/10 星期三 23:13:56
 * File Name: 233.cpp
 * State: 
 * Memo: 
 */
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;

const int MaxA=3e4+7;

struct Edge {
    int v, nt;
    Edge(){}
    Edge(int v, int nt):v(v), nt(nt){}
} edges[MaxA<<1];

int head[MaxA], edgeNum;

struct SegmentTree {
    int n;
    int c[MaxA<<2][2]; ///0:sum 1:max
    int *val;
    int p, v;
    int L, R, op;
#define lson l, m, rt<<1
#define rson m+1, r, rt<<1|1
    
    void pushUp(int rt) {
        c[rt][0]=c[rt<<1][0]+c[rt<<1|1][0];
        c[rt][1]=max(c[rt<<1][1], c[rt<<1|1][1]);
    }

    void doBuild(int l, int r, int rt) {
        if(l==r) {
            c[rt][0]=c[rt][1]=val[l];
        } else {
            int m=(l+r)>>1;
            doBuild(lson);
            doBuild(rson);
            pushUp(rt);
        }
    }

    void build(int n, int* val) {
        this->n=n; this->val=val;
        doBuild(1, n, 1);
    }

    void doUpdate(int l, int r, int rt) {
        if(l==r) {
            c[rt][0]=c[rt][1]=v;
        } else {
            int m=(l+r)>>1;
            if(p<=m) doUpdate(lson);
            else doUpdate(rson);
            pushUp(rt);
        }
    }

    void update(int p, int v) {
        this->p=p; this->v=v;
        doUpdate(1, n, 1);
    }

    int doQuery(int l, int r, int rt) {
        if(L<=l && r<=R) {
            return c[rt][op];
        } else {
            int m=(l+r)>>1;
            int res=(op==0?0:0x80000000); 
            if(L<=m) res=(op==0?res+doQuery(lson):max(res, doQuery(lson)));
            if(m<R) res=(op==0?res+doQuery(rson):max(res, doQuery(rson)));
            return res;
        }
    }

    int query(int L, int R, int op) {
        this->L=L; this->R=R; this->op=op;
        return doQuery(1, n, 1);
    }
#undef lson
#undef rson
} st;

int N;
int oval[MaxA], val[MaxA];    ///oval：树结点编号对应的值
                            ///val：线性表编号对应的值
void init() {
    edgeNum=0;
    memset(head, -1, sizeof(head));
}
void addEdge(int u, int v) {
    edges[edgeNum]=Edge(v, head[u]);
    head[u]=edgeNum++;
}
namespace LCT {
    int fa[MaxA];        ///fa[x]：x的父亲结点
    int siz[MaxA];        ///siz[x]：x子树的结点数
    int son[MaxA];        ///son[x]：x的重儿子，即siz最大的儿子（有平行的无所谓，随便一个即可
    int dep[MaxA];        ///dep[x]：x的结点深度
    int top[MaxA];        ///top[x]：x所在重链中dep值最小的结点
                        ///重边：结点与重儿子的连边
                        ///重链：由重边连成的路径
    int w[MaxA];        ///w[x]：x在线性表中的编号
    int id;                ///id：生成w数组时用的计数变量

    int dfs1(int u, int d) {
        siz[u]=1; dep[u]=d; son[u]=-1;
        for(int i=head[u]; ~i; i=edges[i].nt) {
            Edge& e=edges[i];
            if(e.v==fa[u]) continue;
            fa[e.v]=u;
            siz[u]+=dfs1(e.v, d+1);
            if(son[u]==-1 || siz[son[u]]<siz[e.v]) son[u]=e.v;
        }
        return siz[u];
    }

    void dfs2(int u, int tp) {    
        w[u]=++id; top[u]=tp;
        if(son[u]!=-1) dfs2(son[u], tp);
        for(int i=head[u]; ~i; i=edges[i].nt) {
            Edge& e=edges[i];
            if(e.v==fa[u] || e.v==son[u]) continue;
            dfs2(e.v, e.v);
        }
    }

    int query(int u, int v, int op) {
        int res=(op==0?0:0x80000000);
        int f1=top[u], f2=top[v];
        while(f1!=f2) {
            if(dep[f1]<dep[f2]) { swap(f1, f2); swap(u, v); }
            res=(op==0?res+st.query(w[f1], w[u], op):max(res, st.query(w[f1], w[u], op)));
            u=fa[f1]; f1=top[u];
        }
        if(dep[u]>dep[v]) swap(u, v);
        res=(op==0?res+st.query(w[u], w[v], op):max(res, st.query(w[u], w[v], op)));
        return res;
    }

    void update(int p, int v) {
        st.update(w[p], v);
    }
    
    void init() {
        int root=1;    ///随便指定树根
        id=0;
        fa[root]=-1;
        dfs1(root, 0);
        dfs2(root, root);
        for(int i=1; i<=N; i++) {
            val[w[i]]=oval[i];
        }
        st.build(N, val);
    }
}
int main() {
#ifndef ONLINE_JUDGE
    freopen("in", "r", stdin);
    //freopen("out", "w", stdout);
#endif
    while(~scanf("%d", &N)) {
        init();
        for(int i=1; i<N; i++) {
            int a, b;
            scanf("%d%d", &a, &b);
            addEdge(a, b);
            addEdge(b, a);
        }
        for(int i=1; i<=N; i++) {
            scanf("%d", &oval[i]);
        }
        LCT::init();
        int Q;
        scanf("%d", &Q);
        while(Q--) {
            char op[7];
            int a, b;
            scanf("%s%d%d", op, &a, &b);
            if(op[0]=='C') {
                LCT::update(a, b);
            } else {
                if(op[1]=='S') {
                    printf("%d
", LCT::query(a, b, 0));
                } else printf("%d
", LCT::query(a, b, 1));
            }
        }
    }
    return 0;
}