下午百度之星複賽裡最簡單的一題，雖然我還是1個小時才AC的，呃，下午果斷被虐粗翔。

本題磨了1個小時才過，第1題還是很猥瑣地用了隨機數過的（真不知道怎麼做）。

回到這題來，其實也不知道大牛們怎麼做的，我只能用線段樹+LCA搞了。

首先考慮根不改變的情況，那麼我們可以將每個結點對映到線段樹上去，讓每個點對應的子樹的點都落在某個連續區間上；

具體是在dfs的時候，用id來表示當前已經對映到線段樹的編號，初始為0，進入某個結點X，令left[X]=right[X]=++id，然後繼續dfs，對於X每個子節點j，dfs完了順便更新right[X]=max(right[X], right[j])，這樣在所有子節點遍歷完的情況下，left[X]到right[X]就剛好是以X為根的子樹的區間。在紙上模擬下就明白了。

然後對於查詢和點更新就是個經典的線段樹問題了。

比較麻煩的是根被改變的情況，假設我們現在要查詢以X為根的子樹的和，分析下當前根是root時與原先的不同。如果root原來就是X的祖先了，那麼答案跟原來是一樣的，再往下想其實就是隻要root需要經過X原先某個祖先到達X的話，答案應該都一樣的，所以這個好辦。

而如果X剛好就是root，那麼答案就是整棵樹的和，也好處理。

剩下的就是原來X是root的祖先，我們假設X經過它的某個子節點Y到達root，那麼很明顯當前X的子樹和，應該是整棵樹的值減去原來Y對應的子樹的和。因為X-Y這條邊是root進行dfs到達X的最後一條邊，換句話說這條邊就把是不是X的子樹的點分隔開了。

分析到這裡問題就好辦了，對於查詢X，求出它們的最近公共祖先V，再進行判斷即可。

#include<cstdio>
#include<cstring>
#include<vector>
#include<algorithm>
using namespace std;
#define lson o<<1
#define rson (o<<1)|1
#define N 10001
#define pb push_back
vector<int> V[N];
int t, ct, n;
int left[N], right[N], val[N], v2[N];
int s[N<<2], l[N<<2], r[N<<2];
int id, root;
bool f[N];
int depth[N], parent[16][N];
void dfs(int x){
    left[x] = right[x] = ++id;
    v2[id] = val[x];
    for(int i=0; i<V[x].size(); i++){
        int j=V[x][i];
        if(f[j])    continue;
        f[j]=1;
        depth[j] = depth[x]+1;
        parent[0][j] = x;
        dfs(j);
        right[x] = max(right[x], right[j]);
    }
}
void maintain(int o){
    s[o] = s[lson]+s[rson];
}
void build(int o, int ll, int rr){
    l[o]=ll; r[o]=rr;
    s[o]=0;
    if(ll<rr){
        int m = (ll+rr)>>1;
        build(lson, ll, m);
        build(rson, m+1, rr);
        maintain(o);
    }
    else{
        s[o] = v2[ll];
    }
}
void update(int o, int p, int v){
    if(l[o]==p && r[o]==p){
        s[o]=v;
        return;
    }
    int m = (l[o]+r[o])>>1;
    if(p<=m)    update(lson, p, v);
    else    update(rson, p, v);
    maintain(o);
}
void init_lca(){
    for(int k=0; k<15; k++){
        for(int v=1; v<=n; v++){
            if(parent[k][v]<0)  parent[k+1][v]=-1;
            else    parent[k+1][v] = parent[k][parent[k][v]];
        }
    }
}
int lca(int u, int v){
    if(depth[u]>depth[v]){
        swap(u,v);
    }
    for(int k=0; k<16; k++){
        if((depth[v]-depth[u])>>k & 1){
            v = parent[k][v];
        }
    }
    if(u==v)    return u;
    for(int k=15; k>=0; k--){
        if(parent[k][u]!=parent[k][v]){
            u=parent[k][u];
            v=parent[k][v];
        }
    }
    return parent[0][u];
}
int query(int o, int ll, int rr){
    if(l[o]==ll && r[o]==rr)    return s[o];
    int m = (l[o]+r[o])>>1;
    if(rr<=m)   return query(lson, ll, rr);
    else if(ll>m)   return query(rson, ll, rr);
    else    return query(lson, ll, m)+query(rson, m+1, rr);
}
int query(int x){
    if(x==root) return s[1];
    int v = lca(root, x);
    if(v!=x){
        return query(1, left[x], right[x]);
    }
    for(int i=0; i<V[x].size(); i++){
        int j=V[x][i];
        if(depth[j]<depth[x])   continue;
        v = lca(root, j);
        if(v==j){//找到前面所說的Y
            return s[1] - query(1, left[j], right[j]);
        }
    }
    return 0;
}
inline void in(int &x){
    char c=getchar();
    x=0;
    while(c<48 || c>57) c=getchar();
    while(c>=48 && c<=57){
        x = x*10+c-48;
        c = getchar();
    }
}
int main(){
    in(t);
    for(ct=1; ct<=t; ct++){
        printf("Case #%d:\n", ct);
        in(n);
        for(int i=1; i<=n; i++) V[i].clear();
        int x, y;
        for(int i=1; i<n; i++){
            in(x); in(y);
            V[x].pb(y);
            V[y].pb(x);
        }
        for(int i=1; i<=n; i++){
            in(val[i]);
        }
        memset(f,0,sizeof(f));
        memset(parent,-1,sizeof(parent));
        f[1]=1;
        id = 0;
        depth[1]=1;
        dfs(1);
        init_lca();
        build(1, 1, n);
        int q;
        char op[10];
        in(q);
        root=1;
        while(q--){
            scanf("%s", op);
            in(x);
            if(op[0]=='Q'){
                printf("%d\n", query(x));
            }
            else if(op[0]=='C'){
                in(y);
                update(1, left[x], y);
            }
            else{
                root = x;
            }
        }
    }
    return 0;
}