LCT（Cave 洞穴勘測，BZOJ 2049）

題目鏈接：http://www.lydsy.com/JudgeOnline/problem.php?id=2049

第一次寫LCT

LCT介紹：

http://blog.csdn.net/saramanda/article/details/55253627

http://blog.csdn.net/d891320478/article/details/9181385

LCT論文：

https://wenku.baidu.com/view/75906f160b4e767f5acfcedb

本題題解：

http://www.cnblogs.com/kuangbin/archive/2013/09/03/3300141.html

把如下代碼

void cut(int u,int v)
{
    mroot(u);
    access(v);
    Splay(v);
    pushdown(v);
    T[u].fa=T[v].ch[0]=0;
}

改成

void cut(int u,int v){
    mroot(u);
    Splay(v);
    T[T[v].ch[0]].fa=T[v].fa;
    T[T[v].ch[0]].is_root=true;
    T[v].fa=0;T[v].ch[0]=0;
}

就不會RE

也不知道爲什麼。

代碼

/**************************************************************
    Problem: 2049
    User: 2015190026
    Language: C++
    Result: Accepted
    Time:1720 ms
    Memory:976 kb
****************************************************************/
 
#include<stdio.h>
#include<algorithm>
using namespace std;
const int maxn = 10010;
 
struct node
{
    int fa,ch[2];
    bool reverse,is_root;
    void init()
    {
        fa=ch[0]=ch[1]=0;
        reverse=0;
        is_root=1;
    }
}T[maxn];
 
int getson(int x)
{
    return x==T[T[x].fa].ch[1];
}
 
void pushreverse(int x)
{
    if(!x) return;
    swap(T[x].ch[0],T[x].ch[1]);
    T[x].reverse^=1;
}
 
void pushdown(int x)
{
    if(T[x].reverse)
    {
        pushreverse(T[x].ch[0]);
        pushreverse(T[x].ch[1]);
        T[x].reverse=false;
    }
}
 
void rotate(int x)
{
    if(T[x].is_root) return;
    int k=getson(x);
    int fa=T[x].fa;
    int fafa=T[fa].fa;
    pushdown(fa);
    pushdown(x);
    T[fa].ch[k]=T[x].ch[k^1];
    if(T[x].ch[k^1]) T[T[x].ch[k^1]].fa=fa;
    T[x].ch[k^1]=fa;
    T[fa].fa=x;
    T[x].fa=fafa;
    if(T[fa].is_root)
    {
        T[fa].is_root=false;
        T[x].is_root=true;
    }
    else
    {
        T[fafa].ch[fa==T[fafa].ch[1]]=x;
    }
}
 
void push(int x)
{
    if(!T[x].is_root) push(T[x].fa);
    pushdown(x);
}
 
void Splay(int x)
{
    push(x);
    for(int fa;!T[x].is_root;rotate(x))
    {
        if(!T[fa=T[x].fa].is_root)
        {
            rotate((getson(x)==getson(fa))?fa:x);
        }
    }
}
 
void access(int x)
{
    int y=0;
    do
    {
        Splay(x);
        T[T[x].ch[1]].is_root=true;
        T[T[x].ch[1]=y].is_root=false;
        x=T[y=x].fa;
    }while(x);
}
 
void mroot(int x)
{
    access(x);
    Splay(x);
    pushreverse(x);
}
 
void link(int u,int v)
{
    mroot(u);
    T[u].fa=v;
}
 
void cut(int u,int v){
    mroot(u);
    Splay(v);
    T[T[v].ch[0]].fa=T[v].fa;
    T[T[v].ch[0]].is_root=true;
    T[v].fa=0;T[v].ch[0]=0;
}
 
int n,m;
char op[20];
int u,v;
 
bool ok(int u,int v)
{
    while(T[u].fa) u=T[u].fa;
    while(T[v].fa) v=T[v].fa;
    return u==v;
}
 
void solve()
{
    for(int i=1;i<=n;i++)
        T[i].init();
    for(int i=1;i<=m;i++)
    {
        scanf("%s%d%d",op,&u,&v);
        if(op[0]=='Q')
        {
            if(ok(u,v)) puts("Yes");
            else puts("No");
        }
        else if(op[0]=='D') cut(u,v);
        else link(u,v);
    }
}
 
int main()
{
    while(~scanf("%d %d",&n,&m)) solve();
    return 0;
}