【BZOJ1036】【LCT版】树的统计Count

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

【分析】

随便写了一个LCT的版本，比树链剖分慢...

现在发现LCT真是个好东西，好写又有用。

 /*
 唐代白居易
 《白云泉》
 天平山上白云泉，云自无心水自闲。
 何必奔冲山下去，更添波浪向人间。
 */
 #include <iostream>
 #include <cstdio>
 #include <algorithm>
 #include <cstring>
 #include <vector>
 #include <utility>
 #include <iomanip>
 #include <string>
 #include <cmath>
 #include <queue>
 #include <assert.h>
 #include <map>
 #include <ctime>
 #include <cstdlib>
 #include <stack>
 #define LOCAL
 const int INF = 0x7fffffff;
 const int MAXN =   + ;
 const int maxnode = ;
 const int maxm=  *  + ;
 using namespace std;

 struct Link_Cut_Tree{
        struct Node{
               int val, sum, Max;//用来debug
               int delta;
               Node *parent;
               Node *ch[];
        }node[MAXN], *cur, _null, *null;
        Node *tmp[MAXN];

        bool is_root(Node* t){//判断是否是splay的根
             if (t == null || (t->parent->ch[] != t && t->parent->ch[] != t)) return ;
             return ;
        }
        //本来以为不要pushdown了，结果还是要
        void pushdown(Node *t){
             if (t == null) return;
             if (t->delta){
                t->delta = ;
                if (t->ch[] != null) t->ch[]->delta ^= ;
                if (t->ch[] != null) t->ch[]->delta ^= ;
                swap(t->ch[], t->ch[]);
             }
        }
        //更新
        void update(Node *t){
             if (t == null) return;
             t->sum = t->val;
             if (t->ch[] != null) t->sum += t->ch[]->sum;
             if (t->ch[] != null) t->sum += t->ch[]->sum;
             t->Max = max(t->val, max(t->ch[]->Max, t->ch[]->Max));
             return;
        }
        void init(){
             null = &_null;
             _null.val = _null.sum = _null.Max = -INF;
             _null.delta = ;
             _null.parent = _null.ch[] = _null.ch[] = null;

             cur = node + ;
        }
        Node* NEW(int val){
             cur->parent = cur->ch[] = cur->ch[] = null;
             cur->val = cur->Max = cur->sum = val;
             cur->delta = ;
             return cur++;
        }
        void rotate(Node *t, int d){
             if (is_root(t)) return;
             Node *p = t->parent;
             p->ch[d ^ ] = t->ch[d];
             if (t->ch[d] != null) t->ch[d]->parent = p;
             t->parent = p->parent;
             if (p != null){
                if (p->parent->ch[] == p) p->parent->ch[] = t;
                else if (p->parent->ch[] == p) p->parent->ch[] = t;
             }
             t->ch[d] = p;
             p->parent = t;
             update(t);
             update(p);//真逗，什么都不要
        }
        //将t旋转到根
        void splay(Node *t){
             //标记下传
             int cnt = ;
             tmp[] = t;
             for (Node *y = t; !is_root(y); y = y->parent) tmp[cnt++] = y->parent;
             while (cnt) pushdown(tmp[--cnt]);

             while (!is_root(t)){
                   Node *y = t->parent;
                   if (is_root(y)) rotate(t, (y->ch[] == t));
                   else {
                        int d = (y->parent->ch[] == y);
                        if (y->ch[d] == t) rotate(t, d ^ );
                        else rotate(y, d);
                        rotate(t, d);
                   }
                   update(t);
             }
             update(t);
        }
        Node* access(Node *t){
             Node *p = null;
             while (t != null){
                   splay(t);
                   if (p != null) p->parent = t;
                   t->ch[] = p;
                   update(t);
                   p = t;
                   t = t->parent;
             }
             return p;
        }
        //合并u,v所在的树
        void merge(Node *u, Node *v){
             access(u);
             splay(u);
             u->delta = ;
             u->parent = v;
             return;
        }
        void cut(Node *u, Node *v){
             access(u)->delta ^= ;
             //splay(u);//转到顶上就切断v就可以了
             access(v);
             splay(v);

             v->ch[]->parent = null;
             v->ch[] = null;
             return;
        }
        //找根
        Node *find(Node *t){
             access(t);
             splay(t);
             while (t->parent != null) t = t->parent;
             return t;
        }
        bool check(Node *u, Node *v){
             while (u->parent != null) u = u->parent;
             while (v->parent != null) v = v->parent;
             return (u == v);
        }
        void change(Node *l, int x){
             access(l);
             splay(l);
             l->val = x;
             update(l);
        }
 }splay;
 int n, m;
 int u[MAXN] , v[MAXN];

 void init(){
      splay.init();
      scanf("%d", &n);
      for (int i = ; i < n; i++) scanf("%d%d", &u[i], &v[i]);
      for (int i = ; i <= n; i++){
          int a;
          scanf("%d", &a);
          splay.NEW(a);
      }
      for (int i = ; i < n; i++)
      splay.merge(splay.node + u[i], splay.node + v[i]);
 }
 void work(){
      int m ;
      scanf("%d", &m);
      for (int i = ; i <= m; i++){
          char str[];
          scanf("%s", str);
          if (str[] == 'C'){
             int l, x;
             scanf("%d%d", &l, &x);//将l的值改为x
             splay.change(splay.node + l, x);
          }else if (str[] == 'Q'){
                int l, r;
                scanf("%d%d", &l, &r);
                if (str[] == 'S'){
                   splay.access(splay.node + l)->delta ^= ;//换根
                   splay.access(splay.node + r);
                   Link_Cut_Tree::Node *p = splay.find(splay.node + r);
                   printf("%d\n", p->sum);
                }else{//求最大值
                   splay.access(splay.node + l)->delta ^= ;//换根
                   splay.access(splay.node + r);
                   Link_Cut_Tree::Node *p = splay.find(splay.node + r);
                   printf("%d\n", p->Max);
                }
          }
      }
 }

 int main (){

     init();
     work();
     return ;
 }