【HDU4010】【LCT】Query on The Trees

Problem Description

We have met so many problems on the tree, so today we will have a query problem on a set of trees.
There
are N nodes, each node will have a unique weight Wi. We
will have four kinds of operations on it and you should solve them
efficiently. Wish you have fun!

 

Input

There are multiple test cases in our dataset.
For
each case, the first line contains only one integer N.(1 ≤ N ≤
300000) The next N‐1 lines each contains two integers x, y which means
there is an edge between them. It also means we will give you one tree
initially.
The next line will contains N integers which means the weight Wi of each node. (0 ≤ Wi ≤ 3000)
The
next line will contains an integer Q. (1 ≤ Q ≤ 300000) The next Q
lines will start with an integer 1, 2, 3 or 4 means the kind of this
operation.
1. Given two integer x, y, you should make a new edge
between these two node x and y. So after this operation, two trees will
be connected to a new one.
2. Given two integer x, y, you should
find the tree in the tree set who contain node x, and you should make
the node x be the root of this tree, and then you should cut the edge
between node y and its parent. So after this operation, a tree will be
separate into two parts.
3. Given three integer w, x, y, for the x, y and all nodes between the path from x to y, you should increase their weight by w.
4.
Given two integer x, y, you should check the node weights on the path
between x and y, and you should output the maximum weight on it.

 

Output

For
each query you should output the correct answer of it. If you find this
query is an illegal operation, you should output ‐1.
You should output a blank line after each test case.

 

Sample Input

5
1 2
2 4
2 5
1 3
1 2 3 4 5
6
4 2 3
2 1 2
4 2 3
1 3 5
3 2 1 4
4 1 4

 

Sample Output

3
-1
7

Hint

We define the illegal situation of different operations:
In first operation: if node x and y belong to a same tree, we think it's illegal.
In second operation: if x = y or x and y not belong to a same tree, we think it's illegal.
In third operation: if x and y not belong to a same tree, we think it's illegal.
In fourth operation: if x and y not belong to a same tree, we think it's illegal.

Source

The 36th ACM/ICPC Asia Regional Dalian Site —— Online Contest

 

Recommend

lcy   |   We have carefully selected several similar problems for you:  4004 4005 4006 4007 4001

【分析】

相当优美，巧妙的数据结构。

这题是入门题，关键在于区别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{//splay节点
               int val, add;
               int Max, turn;
               Node *parent, *ch[];
        }node[MAXN], *null;
        Node *pos;//计数
        Node *tmp[MAXN];

        void change(Node *u){access(u)->turn ^= ;}//注意因为x是在右子树要翻转
        void init(){
             //循环指针
             null = node;
             null->parent = null->ch[] = null->ch[] = null;
             null->Max = null->val = -INF;
             null->add = null->turn = ;

             pos = node + ;
        }
        //用这种方法实现快捷方便.便于直接查找
        Node *NEW(int x){
             pos->Max = pos->val = x;
             pos->turn = pos->add = ;
             pos->parent = pos->ch[] = pos->ch[] = null;
             return pos++;
        }
        //判断x是否是根，注意这个是判断是否是splay的根，而不是lct的根
        bool is_root(Node *x){
             if (x == null || (x->parent->ch[] != x && x->parent->ch[] != x)) return ;
             return ;
        }
        //标记下传
        void pushdown(Node *x){
             if (x == null) return;
             if (x->turn){//翻转标记 

                if (x->ch[] != null) x->ch[]->turn ^= ;
                if (x->ch[] != null) x->ch[]->turn ^= ;
                swap(x->ch[], x->ch[]);//交换左右子树.
                x->turn = ;
             }
             //权值标记
             if (x->add){
                if (x->ch[] != null){
                   x->ch[]->val += x->add;
                   x->ch[]->Max += x->add;
                   x->ch[]->add += x->add;
                }
                if (x->ch[] != null){
                   x->ch[]->val += x->add;
                   x->ch[]->Max += x->add;
                   x->ch[]->add += x->add;
                }
                x->add = ;
             }
             return;
        }
        //更新
        void update(Node *x){
             if (x == null) return;
             x->Max = max(x->val, max(x->ch[]->Max, x->ch[]->Max));
        }

        //d = 0为左旋,否则为右旋
        void rotate(Node *x, int d){
             if (is_root(x)) return;//是根就不转
             Node *y = x->parent;
             y->ch[d ^ ] = x->ch[d];
             if (x->ch[d] != null) x->ch[d]->parent = y;
             x->parent = y->parent;
             if (y != null){
                if (y == y->parent->ch[]) y->parent->ch[] = x;
                else if (y == y->parent->ch[]) y->parent->ch[] = x;
             }
             x->ch[d] = y;
             y->parent = x;
             update(y);
        }
        //将x转到根
        void splay(Node *x){
             //带标记splay的伸展操作
             //将从顶部到根部的节点全部pushdown
             int cnt = ;
             tmp[] = x;
             for (Node *y = x; !is_root(y); y = y->parent) tmp[cnt++] = y->parent;
             while (cnt) pushdown(tmp[--cnt]);

             while (!is_root(x)){
                   Node *y = x->parent;
                   if (is_root(y)) rotate(x, (x == y->ch[]));
                   else {
                        int d = (y->parent->ch[] == y);
                        if (y->ch[d] == x) rotate(x, d ^ );
                        else rotate(y, d);
                        rotate(x, d);
                   }
             }
             update(x);
        }
        //lct的访问操作,也是核心代码
        Node *access(Node *u){
             Node *v = null;
             while (u != null){//非lct根，总是放在右边
                   splay(u);
                   v->parent = u;
                   u->ch[] = v;
                   update(u);
                   v = u;
                   u = u->parent;
             }
             return v;
        }
        //合并操作
        void merge(Node *u, Node *v){
             //if (u->val == 2 && v->val == 5)
             //printf("%d\n", u->ch[0]->val);
             //注意u为根
             access(u);
             splay(u);

             u->turn = ;//翻转,因为在access之后，u已经成为splay中深度最大的点，因此右子树为null，此时要成为根就要翻转
             u->parent = v;
        }
        void cut(Node *u){
             access(u);
             splay(u);
             //注意到u为根，自然深度最小,分离出来
             u->ch[]->parent = null;
             u->ch[] = null;
             update(u);
        }
        //找根,不是真根
        Node *findroot(Node *u){
             access(u);//不仅要打通，而且要让u成为根
             splay(u);

             while (u->parent != null) u = u->parent;
             return u;
        }
        //判断u和v是否在同一个子树中
        bool check(Node *u, Node *v){
             while (u->parent != null) u = u->parent;
             while (v->parent != null) v = v->parent;
             return (u == v);
        }
 }splay;
 int u[MAXN],v[MAXN];
 int n, m;
 /*struct Node{
        Node *ch[2];
        int val;
 };
 Node* rotate(Node *t, int d){
      Node *p = t->ch[d ^ 1];
      t->ch[d ^ 1] = p->ch[d];
      p->ch[d] = t;
      t =  p;
      return t;
 }*/
 void init(){
      splay.init();
      for (int i = ; i < n; i++) scanf("%d%d", &u[i], &v[i]);
      //各点权值
      for (int i = ; i <= n; i++){
          int t;
          scanf("%d", &t);
          splay.NEW(t);
      }
      for (int i = ; i < n; i++) {
         // if (i == 3)
         // printf("");
          splay.merge(splay.node + u[i], splay.node + v[i]);
          //printf("%d\n", splay.node[2].ch[0]->val);
      }
      //printf("%d", splay.check(splay.node + 4, splay.node + 5));
 }
 void work(){
      scanf("%d", &m);
      for (int i = ; i <= m; i++){
          int t;
          scanf("%d", &t);
          if (t == ){//连接两点
             int u, v;
             scanf("%d%d", &u, &v);
             //判断是否在同一个lct树内
             if (splay.check(splay.node + u, splay.node + v)){
                //printf("%d ", i);
                printf("-1\n");
                continue;
             }
             splay.merge(splay.node + u, splay.node + v);
          }else if (t == ){
             int u, v;
             scanf("%d%d", &u, &v);
             //分离两颗树
             if (u == v || !splay.check(splay.node + u, splay.node + v)){
                //printf("%d ", i);
                printf("-1\n");
                continue;
             }
             //转根再分离
             splay.change(splay.node + u);//注意这个根是原树的根不是lct的根
             splay.cut(splay.node + v);
          }else if (t == ){
                int u, v, w;
                scanf("%d%d%d", &w, &u, &v);
                //不再同一个树内自然无法更新
                if (!splay.check(splay.node + u, splay.node + v)){
                   //printf("%d ", i);
                   printf("-1\n");
                   continue;
                }
                splay.change(splay.node + u);
                splay.access(splay.node + v);
                //将u换为真根，则u所在的splay都是v-u路径上的节点
                Link_Cut_Tree::Node *q = splay.findroot(splay.node + v);
                q->add += w;
                q->Max += w;
                q->val += w;
          }else {//查询操作
                int u, v;
                scanf("%d%d", &u, &v);
                if (!splay.check(splay.node + u, splay.node + v)){
                   //printf("%d ", i);
                   printf("-1\n");
                   continue;
                }
                //先换根
                splay.change(splay.node + u);
                splay.access(splay.node + v);
                printf("%d\n", splay.findroot(splay.node + v)->Max);
          }
      }
      printf("\n");
 }

 int main (){

     //scanf("%d", &n);
     while (scanf("%d", &n) != EOF){
           init();
           work();
     }
     return ;
 }