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

题目描述

给定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。

输入输出格式

输入格式：
第1行两个整数，分别为n和m，代表点数和操作数。

第2行到第n+1行，每行一个整数，整数在［1，10^9］内，代表每个点的权值。

第n+2行到第n+m+1行，每行三个整数，分别代表操作类型和操作所需的量。

输出格式：
对于每一个0号操作，你须输出x到y的路径上点权的xor和。

输入输出样例

输入样例#1：
3 3
1
2
3
1 1 2
0 1 2
0 1 1
输出样例#1：
3
1
说明

数据范围：1≤N,M≤3*10^5

分析：显然是道LCT的模板题，学了几天终于会了。有错误记得告诉我哟。感觉洛谷数据好水。

代码：

#include 
#include 

const int maxn=3e5+5;

using namespace std;

struct node{
    int l,r,s,fa,size;
    //l为左儿子，r为右儿子，s为一棵子树的xor值，fa为父亲，size为子树大小
    bool rev;//左右交换标记
}t[maxn];

int val[maxn];
int n,m,i,op,x,y;

void updata(int x)//更新size和s
{
    t[x].s=t[t[x].l].s^t[t[x].r].s^val[x];
    t[x].size=t[t[x].l].size+t[t[x].r].size+1;
}

bool is_root(int x)//判断一个点是不是当前splay的根
{
    return (x!=t[t[x].fa].l) && (x!=t[t[x].fa].r);
}

void rttr(int x)//右旋
{
    int y=t[x].l;//记左儿子为y
    t[x].l=t[y].r;//x的左儿子变为y的右儿子
    if (t[y].r) t[t[y].r].fa=x;//更新y.son的父亲
    if (t[t[x].fa].l==x) t[t[x].fa].l=y;
    else if (t[t[x].fa].r==x) t[t[x].fa].r=y;//更新x父亲的儿子(需要判断x为左儿子还是右儿子)
    t[y].fa=t[x].fa;//y的父亲变为x父亲
    t[x].fa=y;//x的父亲变为y
    t[y].r=x;//y的右儿子变为x
    updata(x); updata(y);//更新维护的值
}

void rttl(int x)//左旋，其实差不多
{
    int y=t[x].r;
    t[x].r=t[y].l;
    if (t[y].l) t[t[y].l].fa=x;
    if (t[t[x].fa].l==x) t[t[x].fa].l=y;
    else if (t[t[x].fa].r==x) t[t[x].fa].r=y;
    t[y].fa=t[x].fa;
    t[x].fa=y;
    t[y].l=x;
    updata(x); updata(y);
}

void remove(int x)//清除标记
{
    if (!is_root(x)) remove(t[x].fa);//先把父亲的解决了
    if (t[x].rev)//需要交换
    {
        t[x].rev^=1;
        swap(t[x].l,t[x].r);
        if (t[x].l) t[t[x].l].rev^=1;//儿子也要交换，所以异或以下就好
        if (t[x].r) t[t[x].r].rev^=1;
    }
}

void splay(int x)
{
    remove(x);//先交换完
    while (!is_root(x))
    {
        int p=t[x].fa,g=t[p].fa;
        if (is_root(p))//单旋
        {
            if (x==t[p].l) rttr(p); else rttl(p);
        }
        else //双旋
        {
            if (x==t[p].l)
            {
                if (p==t[g].l) rttr(p),rttr(g);
                          else rttr(p),rttl(g);
            }
            else
            {
                if (p==t[g].l) rttl(p),rttr(g);
                          else rttl(p),rttl(g);
            }
        }
    }
}

void access(int x) //把x到根的路径都变成重链，加入同一个splay
{
    int y=0;
    while (x)
    {
        splay(x);//把x旋到根
        t[x].r=y;//切断原本的右儿子，接上新的右儿子，因为原本的右儿子深度比x深，所以一定是他的儿子，这句其实是换重链
        updata(x);//更新
        y=x;x=t[x].fa;//当前x一定为splay的根，通过轻链往上跳
    }
}

void make_root(int x)//把x设为当前根
{
    access(x);//x先与root连重链，使x与root在同一条链上
    splay(x);//把x变为根
    t[x].rev^=1;//该链上的点的深度全部反转
}

int find(int x)//寻找x的splay上的根
{
    if (is_root(x)) return x;
    else return find(t[x].fa);
}

void link(int x,int y)//连接x，y
{
    make_root(x);先把x设为根
    access(y);//拉一条x到y的重链
    splay(y);//把y旋到根，此时如果x在y的左子树，那么已经存在边
    if (find(x)!=y) t[x].fa=y;//x到y连虚边
}

void cut(int x,int y)
{   
    make_root(x);//和上面差不多
    access(y);
    splay(y);
    if ((t[y].l==x) && (t[t[y].l].size==1))t[y].l=0,t[x].fa=0;
    //必须保证x在y的左边，而且左边只有一个点，因为x已经是根，那么y要和x相连，就要是深度第二大
}


int main()
{
    scanf("%d%d",&n,&m);
    for (i=1;i<=n;i++)
    {
        scanf("%d",&val[i]);
    }  
    for (i=1;i<=m;i++)
    {
        scanf("%d%d%d",&op,&x,&y);
        if (op==0)
        {           
            make_root(x);//把x设为根
            access(y);//拉一条链
            splay(y);//旋转，此时x到y的路径一定在同一splay
            printf("%d\n",t[y].s);//那么跟就是答案了
        }
        if (op==1) link(x,y);
        if (op==2) cut(x,y);
        if (op==3)
        {
            access(x); 
            splay(x); //把x旋到根，这样就可以不用更新该节点的父亲节点
            val[x]=y; 
            updata(x);
        }
    }
}