HDU 4010 Query on The Trees (动态树)(Link-Cut-Tree)

题目链接：

http://acm.hdu.edu.cn/showproblem.php?pid=4010

题意;

先给你一棵树，有 \(4\) 种操作：

1、如果 \(x\) 和 \(y\) 不在同一棵树上则在\(x-y\)连边.

2、如果 \(x\) 和 \(y\) 在同一棵树上并且 \(x!=y\) 则把 \(x\) 换为树根并把 \(y\) 和 \(y\) 的父亲分离.

3、如果 \(x\) 和 \(y\) 在同一棵树上则 \(x\) 到 \(y\) 的路径上所有的点权值\(+w\).

4、如果 \(x\) 和 \(y\) 在同一棵树上则输出 \(x\) 到 \(y\) 路径上的最大值.

题解：

需要支持连边和删边等操作的，一般是动态树。

先把初始化的树建好，再套个 \(LCT\) 就可以了。可以说很裸了....但要注意题目中的一些细节。然而我还是调了挺久的...

\(LCT\) 的基本操作复杂度均摊是\(O(log^2n)\)，不过常数可能大一点。

代码：

#include  <bits/stdc++.h>
using namespace std;
typedef long long ll;
// 动态树问题，即要求我们维护一个由若干棵子结点无序的有根树组成的森林的连通性问题。
// 要求这个数据结构支持对树的分割、合并，对某个点到它到根的路径的某些操作
// LCT的基本操作复杂度为均摊O(log^2n).
// http://acm.hdu.edu.cn/showproblem.php?pid=4010
const int N = 300100;
int n,m,val[N];
struct Link_Cut_Tree
{
    int top,son[N][2],fa[N],q[N],rev[N];
    int NodeVal[N]; // 每个点的权值
    int MAX[N];
    int ADD[N];
    void init()
    {
      for(int i=0;i<=n;i++) {
        son[i][0] = son[i][1] = 0;
      }
      top = 0;
      memset(son,0,sizeof(son));
      memset(fa,0,sizeof(fa));
      memset(q,0,sizeof(q));
      memset(rev,0,sizeof(rev));
      memset(NodeVal,0,sizeof(NodeVal));
      memset(MAX,0,sizeof(MAX));
      memset(ADD,0,sizeof(ADD));
    }
    inline void pushup(int x)  //上传Splay的最大值
    {
      MAX[x] = max(MAX[son[x][0]],MAX[son[x][1]]);
      MAX[x] = max(MAX[x],NodeVal[x]);
    }
    void add(int x, int v)
    {
      NodeVal[x] += v;
      MAX[x] += v;
      ADD[x] += v;
    }
    inline void pushdown(int x) //下放Splay的翻转标记
    {
        int l=son[x][0],r=son[x][1];
        if(rev[x]){
            rev[l]^=1;rev[r]^=1;rev[x]^=1;
            swap(son[x][0],son[x][1]);
        }
        if(ADD[x])
        {
          if(son[x][0]) {
            add(son[x][0],ADD[x]);
          }
          if(son[x][1]) {
            add(son[x][1],ADD[x]);
          }
          ADD[x] = 0;
        }
    }
    // 判断这是不是一条重路径的根，只要他的fa指针指向的节点的左右子树都不是他,
    // 证明此时这是一条虚边那么这就是一棵子树的根节点
    inline bool isroot(int x) {
      return !fa[x] || (son[fa[x]][0]!=x && son[fa[x]][1]!=x);
    }
    void rotate(int x) {
        int y=fa[x],z=fa[y],l,r;
        if(son[y][0]==x)l=0;
        else l=1;
        r=l^1;
        if(!isroot(y)) {
          if(son[z][0]==y) son[z][0]=x;
          else son[z][1]=x;
        }
        fa[x]=z; fa[y]=x;
        fa[son[x][r]]=y;
        son[y][l]=son[x][r]; son[x][r]=y;
        pushup(y); pushup(x);
    }
    // 提根
    void splay(int x) {
        top=1;q[top]=x;
        for(int i=x;!isroot(i);i=fa[i]) q[++top]=fa[i];
        for(int i=top;i;i--) pushdown(q[i]);
        while(!isroot(x)) {
            int y=fa[x],z=fa[y];
            if(!isroot(y)) {
                if((son[y][0]==x)^(son[z][0]==y)) rotate(x);
                else rotate(y);
            }
            rotate(x);
        }
    }
    // LCT核心：从当前的节点x向它所在的根节点连一条重路径，相当于把沿路的重路径全都断开，重新拉一条从x到根的重路径
    void access(int x) {
      for(int t=0;x;t=x,x=fa[x]) {
        splay(x);
        son[x][1]=t;
        pushup(x);
      }
    }
    //换根:让 x 成为当前树的根节点
    void makeroot(int x) {
      access(x);
      splay(x);
      rev[x]^=1;
    }
    // 先找到 x 所在的 auxiliary tree(即preferred path)，并查找返回该条路径最小的节点（即根）
    int find_root(int x) {
      access(x);
      splay(x);
      while(son[x][0]) x=son[x][0];
      return x;
    }
    //获取到 x−y所对应的路径,可以通过访问y节点来获取到有关路径的信息
    void split(int x,int y) {
      makeroot(x);
      access(y);
      splay(y);
    }
    // 断开 x 和 y 之间的边
    void cut(int x,int y) {
      split(x,y);
     // if(son[y][0]==x && son[x][1]==0)
     // {
     //   son[y][0]=0, fa[x]=0;
     //   pushup(y);
     // }
     fa[son[y][0]]=0;son[y][0]=0;
     pushup(y);
    }
    // 在 x 和 y 之间连边
    void link(int x,int y) {
      makeroot(x);
      // 注意有些题不保证x,y未联通，还需要判断一下联通性
      // if(find_root(y)==x) return; //两点已经在同一子树中，再连边不合法
      fa[x]=y;
    }
    // 将x-y路径上的权值都加 w
    void add_val(int x,int y,int w)
    {
      split(x,y);
      add(y,w);
    }
    // 输出x-y之间的最大点权
    int query(int x, int y)
    {
      split(x,y);
      return MAX[y];
    }
}LCT;
std::vector<int> ve[N];
void dfs(int u, int fa)
{
  LCT.fa[u] = fa;
  for(int i = 0; i < (int)ve[u].size(); i++){
    int v = ve[u][i];
    if(v == fa)continue;
    dfs(v,u);
  }
}
int main(int argc, char const *argv[]) {
  // freopen("in.txt","r",stdin);
  while(std::cin >> n) {
    memset(val,0,sizeof(val));
    for(int i = 0; i <= n; i++) ve[i].clear();
    LCT.init();
    for(int i = 1; i < n; i++) {
      int u,v;
      scanf("%d%d",&u,&v);
      // LCT.link(u,v);
      ve[u].push_back(v);
      ve[v].push_back(u);
    }
    dfs(1,0);
    for(int i = 1; i <= n; i++) {
      int x;
      scanf("%d", &x);
      LCT.NodeVal[i] = x;
      LCT.MAX[i] = x;
    }
    std::cin >> m;
    for(int i = 1; i <= m; i++) {
      int op, x, y;
      scanf("%d", &op);
      // 连接x到 y，若x到 y已经联通则无需连接
      if(op == 1) {
        scanf("%d%d",&x,&y);
        int xx = LCT.find_root(x), yy = LCT.find_root(y);
        if(xx != yy) LCT.link(x,y);
        else {
          puts("-1");
        }
      }
      // 删除边(x，y)，但不保证边(x，y)存在
      else if(op == 2)
      {
        scanf("%d%d",&x,&y);
        int xx = LCT.find_root(x), yy = LCT.find_root(y);
        if(xx == yy && x != y) LCT.cut(x,y);
        else {
          puts("-1");
        }
      }
      // 将x-y路径上的权值都加 w
      else if(op == 3) {
        int w;
        scanf("%d%d%d",&w,&x,&y);
        // std::cout << "w = " << w << '\n';
        if(LCT.find_root(x) == LCT.find_root(y)) LCT.add_val(x,y,w);
        else puts("-1");
      }
      // 输出x-y之间的最大点权
      else if(op == 4) {
        scanf("%d%d",&x,&y);
        if(LCT.find_root(x) == LCT.find_root(y)) printf("%d\n",LCT.query(x,y));
        else {
          puts("-1");
        }
      }
    }
    puts("");
  }
  return 0;
}