bzoj 1036: [ZJOI2008]树的统计Count (树链剖分)

1036: [ZJOI2008]树的统计Count

Time Limit: 10 Sec   Memory Limit: 162 MB
Submit: 8411   Solved: 3433
[ Submit][ Status][ Discuss]

Description

一棵树上有n个节点，编号分别为1到n，每个节点都有一个权值w。我们将以下面的形式来要求你对这棵树完成一些操作： I. CHANGE u t : 把结点u的权值改为t II. QMAX u v: 询问从点u到点v的路径上的节点的最大权值 III. QSUM u v: 询问从点u到点v的路径上的节点的权值和 注意：从点u到点v的路径上的节点包括u和v本身

Input

输入的第一行为一个整数n，表示节点的个数。接下来n – 1行，每行2个整数a和b，表示节点a和节点b之间有一条边相连。接下来n行，每行一个整数，第i行的整数wi表示节点i的权值。接下来1行，为一个整数q，表示操作的总数。接下来q行，每行一个操作，以“CHANGE u t”或者“QMAX u v”或者“QSUM u v”的形式给出。 对于100％的数据，保证1<=n<=30000，0<=q<=200000；中途操作中保证每个节点的权值w在-30000到30000之间。

Output

对于每个“QMAX”或者“QSUM”的操作，每行输出一个整数表示要求输出的结果。

Sample Input

4
1 2
2 3
4 1
4 2 1 3
12
QMAX 3 4
QMAX 3 3
QMAX 3 2
QMAX 2 3
QSUM 3 4
QSUM 2 1
CHANGE 1 5
QMAX 3 4
CHANGE 3 6
QMAX 3 4
QMAX 2 4
QSUM 3 4

Sample Output

4
1
2
2
10
6
5
6
5
16

HINT

Source

树的分治

hzwer的题解，http://hzwer.com/2543.html。

关键是蒋一瑶神犇模板，ppt说的很清楚。

http://wenku.baidu.com/link?url=SGLjpJtYbJ0HxDYlU_GMXE1qCFS0gbmpDGWPxI7mQuNAsJP0y872mNKwpZ8P054g5XMhFGZbMUjZvN5hcnxFFUEfGBj6-tnkpnJvnVSlqGS

树链剖分就是把树分成一条条链，对于这些链包含链首元素，给他们每个节点编上号，用数据结构去维护。

论文中提到的轻重链剖分，可以证明每个节点到根节点包含的轻链和重链都不超过logn个。每个结点的儿子下面子树结点总数最大的儿子结点son，那么连到son的边就是重边，连到其他儿子节点的就是轻边，连续的重边就构成了重链，其他的就是轻边。可以记录下来每个重链的深度最小的结点belong，当查询两个结点之间的路径时，用于判断某两个结点是否在同一条重链上；如果不在，则可以计算两个节点的最近公共父节点lca，分别找两个节点到lca的路径，然后利用这个belong让这两个结点不断往上爬，直到和lca在同一条重链上。

用线段树维护链的方式参考下面。

#include <cstdio>
#include <cstring>
#include <queue>
using namespace std;
const int N = 30000 + 10;
const int inf = 0x7fffffff;
int n;
struct Edge{int to,nxt;}e[N<<1];
int tot=0;int head[N];
void add(int u,int v){
    e[++tot].to = v; e[tot].nxt = head[u]; head[u] = tot;
    e[++tot].to = u; e[tot].nxt = head[v]; head[v] = tot;
}
int val[N];
void init(){
    scanf("%d",&n);
    int u, v;
    for(int i=1;i<n;i++){
        scanf("%d%d",&u,&v);
        add(u,v);
    }
    for(int i=1;i<=n;i++) scanf("%d", &val[i]);
}
int fa[N][15],dep[N],siz[N],vis[N];
void dfs1(int x){
    siz[x] = 1; vis[x] = 1;
    for(int i=1;i<=14;i++){
        if (dep[x]<(1<<i)) break;
        fa[x][i] = fa[fa[x][i-1]][i-1];
    }
    for(int i=head[x], v; i; i=e[i].nxt){
        v = e[i].to;
        if (vis[v]) continue;
        dep[v] = dep[x] + 1;
        fa[v][0] = x;
        dfs1(v);
        siz[x] += siz[v];
    }
}
int sz=0; int pos[N], belong[N];
void dfs2(int x,int f){
    int k = 0;
    pos[x] = ++sz; belong[x] = f;
    for(int i=head[x], v; i; i=e[i].nxt){
        v = e[i].to;
        if (dep[v] > dep[x] && siz[v] > siz[k]) k = v;
    }
    if (k == 0) return;
    dfs2(k, f);
    for(int i=head[x], v; i; i=e[i].nxt){
        v = e[i].to;
        if (dep[v] > dep[x] && v != k) dfs2(v, v);
    }
}
struct Seg{int l,r,mx,sum;}t[N<<2];
void build(int k,int x,int y){
    t[k].l = x; t[k].r = y;
    if (x == y) return;
    int mid = (x+y)>>1;
    build(k<<1,x,mid);
    build(k<<1|1,mid+1,y);
}
void pushup(int k){
    t[k].mx = max(t[k<<1].mx, t[k<<1|1].mx);
    t[k].sum = t[k<<1].sum + t[k<<1|1].sum;
}
void change(int k,int x,int y){
    int l = t[k].l, r = t[k].r, mid = (l+r)>>1;
    if (l == r){ t[k].mx = t[k].sum = y; return ;}
    if (x <= mid) change(k<<1, x, y);
    else change(k<<1|1, x, y);
    pushup(k);
}
int lca(int x,int y){
    if (dep[x]<dep[y]) swap(x,y);
    int t = dep[x] - dep[y];
    for(int i=0;i<=14;i++){
        if (t&(1<<i)) x=fa[x][i];
    }
    for(int i=14;i>=0;i--){
        if (fa[x][i] != fa[y][i]){
            x = fa[x][i]; y = fa[y][i];
        }
    }
    if (x == y) return x;
    return fa[x][0];
}
int queryMax(int k,int x,int y){
    int l = t[k].l, r = t[k].r, mid = (l+r)>>1;
    if (l == x && y == r) return t[k].mx;
    if (y <= mid) return queryMax(k<<1, x, y);
    else if (x > mid) return queryMax(k<<1|1, x, y);
    else return max(queryMax(k<<1, x, mid), queryMax(k<<1|1, mid+1, y));
}
int solveMax(int x,int f){
    int mx = -inf;
    while(belong[x] != belong[f]){
        mx = max(mx, queryMax(1, pos[belong[x]], pos[x]));
        x = fa[belong[x]][0];
    }
    mx = max(mx, queryMax(1, pos[f], pos[x]));
    return mx;
}
int querySum(int k,int x,int y){
    int l = t[k].l, r = t[k].r, mid = (l+r)>>1;
    if (l == x && y == r) return t[k].sum;
    if (y <= mid) return querySum(k<<1, x, y);
    else if (x > mid) return querySum(k<<1|1, x, y);
    else return querySum(k<<1, x, mid) + querySum(k<<1|1, mid+1, y);
}
int solveSum(int x,int f){
    int sum = 0;
    while(belong[x] != belong[f]){
        sum += querySum(1, pos[belong[x]], pos[x]);
        x = fa[belong[x]][0];
    }
    sum += querySum(1, pos[f], pos[x]);
    return sum;
}
void solve(){
    build(1,1,n);
    for(int i=1;i<=n;i++) change(1,pos[i],val[i]);
    int q; scanf("%d",&q);
    char s[10]; int x, y;
    while(q--){
        scanf("%s %d %d",s,&x,&y);
        if (s[0] == 'C'){
            val[x] = y;
            change(1,pos[x], val[x]);
        }
        else{
            int t = lca(x,y);
            if (s[1] == 'M'){
                printf("%d\n", max(solveMax(x,t), solveMax(y,t)));
            }
            else{
                printf("%d\n", solveSum(x,t) + solveSum(y,t) - val[t]);
            }
        }
    }
}
int main(){
//    freopen("data.in","r",stdin);
    init();
    dfs1(1);
    dfs2(1,1);
    solve();
    return 0;
}