洛谷 P3690 【模板】Link Cut Tree （动态树）

题目链接：https://www.luogu.org/problem/P3690

动态树：动态树是一种超强级数据结构，它比树链剖分更加强大，它能完成树链剖分的基本操作，还能删边，连边。

               它与树链剖分的不同点在于：它的链是可变的，分实链和虚链，因为更加灵活，所以采用了splay进行维护

               想学会动态树，需要前置技能有：树链剖分，splay树，文艺平衡树。

               抽象理解动态树：可以简单理解为每一条链实链都是一颗splay，有一条主实链从某一个点连到根上，其他的都是副实链，这些副实链构成的splay树的父亲指向主实链上的splay树对应的自己的父亲节点（主实链和副实链是自己口胡的，只是为了方便理解）（副实链上面还能再跟子副链......不用管，假装它不存在，比较好理解）

树链剖分是用线段树来维护重链，其实可以理解为把每段重链都分成了一颗线段树，和动态树把每一段实链都分成了一颗splay的道理是一样的。

好了，我吹不下去了，知识有限，请观摩大犇博客：https://www.cnblogs.com/flashhu/p/8324551.html

附上代码：（正常没数组版快，但开O2优化后差不多，也不知道是不是结构体复杂度比较高的问题）

/*
洛谷 P3690 【模板】Link Cut Tree （动态树）
给定n个点以及每个点的权值，要你处理接下来的m个操作。操作有4种。操作从0到3编号。点从1到n编号。
0：后接两个整数(x，y)，代表询问从x到y的路径上的点的权值的xor和。保证x到y是联通的。
1：后接两个整数(x，y)，代表连接x到y，若x到y已经联通则无需连接。
2：后接两个整数(x，y)，代表删除边(x，y)，不保证边(x，y)存在。
3：后接两个整数(x，y)，代表将点x上的权值变成y。
n和m，代表点数和操作数。
第2行到第n+1行，每行一个整数，代表每个点的权值。
第n+2行到第n+m+1行，每行三个整数，分别代表操作类型和操作所需的量。
对于每一个0号操作，你须输出x到y的路径上点权的xor和。

3 3 
1
2
3
1 1 2
0 1 2 
0 1 1
ans:
3
1
*/
#include<bits/stdc++.h>
#define lc c[x][0]
#define rc c[x][1]
#pragma GCC optimize(2)
#define ls(x) T[x].ch[0]
#define rs(x) T[x].ch[1]
#define M 100010
#define kind(x) (rs(T[x].f)==x)
using namespace std;
struct node
{
    int ch[2],f,v,s,tag;
} T[M];
int n,m,st[M];
void downing(int x)
{
    swap(ls(x),rs(x));
    T[x].tag^=1;
}
void down(int x)
{
    if(T[x].tag)
    {
        if(ls(x)) downing(ls(x));
        if(rs(x)) downing(rs(x));
        T[x].tag=0;
    }
}
void up(int x)
{
    T[x].s = T[ls(x)].s ^ T[rs(x)].s ^ T[x].v;
}
int nroot(int x)//判断x是不是splay的根
{
    return ls(T[x].f)==x||rs(T[x].f)==x;
}
void rol(int x)
{
    int fa=T[x].f,ffa=T[fa].f;
    int k=kind(x),w=T[x].ch[!k];
    T[fa].ch[k]=w;
    T[x].ch[!k]=fa;
    if(nroot(fa))T[ffa].ch[kind(fa)]=x;
    T[x].f=ffa;
    T[fa].f=x;
    if(w)T[w].f=fa;
    up(x),up(fa);
}
void splay(int x)
{
    int y=x,z=0;
    st[++z]=y;
    while(nroot(y)) st[++z]=y=T[y].f;
    while(z>0) down(st[z--]);
    while(nroot(x))
    {
        int f=T[x].f,ff=T[f].f;
        if(nroot(f))
        {
            kind(x)^kind(f)?rol(f):rol(x);
        }
        rol(x);
    }
    up(x);
}
void access(int x)//把x到树根的路径拉为实边
{
    for(int y=0; x; x=T[y=x].f)
        splay(x),rs(x)=y,up(x);
}
void makeroot(int x)//把x变为树的根
{
    access(x);
    splay(x);
    downing(x);
}
int query(int x,int y)
{
    makeroot(x);
    access(y);
    splay(y);
    return T[y].s;
}
int findroot(int x)
{
    access(x);
    splay(x);
    while(ls(x))down(x),x=ls(x);
    splay(x);
    return x;
}
void link(int x,int y)
{
    makeroot(x);
    if(findroot(y)!=x)
    {
        T[x].f=y;
    }
}
void cut(int x,int y)
{
    makeroot(x);
    if(findroot(y)==x&&T[y].f==x&&!T[y].ch[0])
    {
        T[x].ch[1]=T[y].f=0;
        up(x);
    }
}
int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1; i<=n; i++) scanf("%d",&T[i].v);
    int opt,x,y;
    while(m--)
    {
        scanf("%d%d%d",&opt,&x,&y);
        if(opt==0)
            printf("%d\n",query(x,y));
        if(opt==1)
            link(x,y);
        if(opt==2)
            cut(x,y);
        if(opt==3)
            splay(x),T[x].v=y;
    }
}