LCT總結——概念篇+洛谷P3690[模板]Link Cut Tree(動態樹)（LCT，Splay）

爲了優化體驗（實際上是強迫症），蒟蒻把總結拆成了兩篇，方便不一樣學習階段的Dalao們切換。

LCT總結——應用篇戳這裏

概念、性質簡述

首先介紹一下鏈剖分的概念（感謝laofu的講課）
鏈剖分，是指一類對樹的邊進行輕重劃分的操做，這樣作的目的是爲了減小某些鏈上的修改、查詢等操做的複雜度。
目前總共有三類：重鏈剖分，實鏈剖分和並不常見的長鏈剖分

重鏈剖分

實際上咱們常常講的樹剖，就是重鏈剖分的經常使用稱呼。
對於每一個點，選擇最大的子樹，將這條連邊劃分爲重邊，而連向其餘子樹的邊劃分爲輕邊。
若干重邊鏈接在一塊兒構成重鏈，用樹狀數組或線段樹等靜態數據結構維護。
至於有怎樣優秀的性質等等，不在本總結的討論範疇了（實際上是由於本蒟蒻連樹剖都不會）

實鏈剖分

一樣將某一個兒子的連邊劃分爲實邊，而連向其餘子樹的邊劃分爲虛邊。
區別在於虛實是能夠動態變化的，所以要使用更高級、更靈活的Splay來維護每一條由若干實邊鏈接而成的實鏈。
基於性質更加優秀的實鏈剖分，LCT(Link-Cut Tree)應運而生。
LCT維護的對象實際上是一個森林。
在實鏈剖分的基礎下，LCT資磁更多的操做

• 查詢、修改鏈上的信息（最值，總和等）
• 隨意指定原樹的根（即換根）
• 動態連邊、刪邊
• 合併兩棵樹、分離一棵樹（跟上面不是一毛同樣嗎）
• 動態維護連通性
• 更多意想不到的操做（能夠往下滑一滑）

想學Splay的話，推薦巨佬yyb的博客

---

LCT的主要性質以下：

1. 每個Splay維護的是一條從上到下按在原樹中深度嚴格遞增的路徑，且中序遍歷Splay獲得的每一個點的深度序列嚴格遞增。
   是否是有點抽象哈
   好比有一棵樹，根節點爲\(1\)（深度1），有兩個兒子\(2,3\)（深度2），那麼Splay有\(3\)種構成方式：
   \(\{1-2\},\{3\}\)
   \(\{1-3\},\{2\}\)
   \(\{1\},\{2\},\{3\}\)（每一個集合表示一個Splay）
   而不能把\(1,2,3\)同放在一個Splay中（存在深度相同的點）

2. 每一個節點包含且僅包含於一個Splay中

3. 邊分爲實邊和虛邊，實邊包含在Splay中，而虛邊老是由一棵Splay指向另外一個節點（指向該Splay中中序遍歷最靠前的點在原樹中的父親）。
   由於性質2，當某點在原樹中有多個兒子時，只能向其中一個兒子拉一條實鏈（只認一個兒子），而其它兒子是不能在這個Splay中的。
   那麼爲了保持樹的形狀，咱們要讓到其它兒子的邊變爲虛邊，由對應兒子所屬的Splay的根節點的父親指向該點，而從該點並不能直接訪問該兒子（認父不認子）。

各類操做

\(access(x)\)

LCT核心操做，也是最難理解的操做。其它全部的操做都是在此基礎上完成的。
由於性質3，咱們不能老是保證兩個點之間的路徑是直接連通的（在一個Splay上）。
access即定義爲打通根節點到指定節點的實鏈，使得一條中序遍歷以根開始、以指定點結束的Splay出現。
蒟蒻深知沒圖的痛苦qwq
因此仍是來幾張圖吧。
下面的圖片參考YangZhe的論文
有一棵樹，假設一開始實邊和虛邊是這樣劃分的（虛線爲虛邊）

那麼所構成的LCT可能會長這樣（綠框中爲一個Splay，可能不會長這樣，但只要知足中序遍歷按深度遞增（性質1）就對結果無影響）

如今咱們要\(access(N)\)，把\(A-N\)的路徑拉起來變成一條Splay。
由於性質2，該路徑上其它鏈都要給這條鏈讓路，也就是把每一個點到該路徑之外的實邊變虛。
因此咱們但願虛實邊從新劃分紅這樣。

而後怎麼實現呢？
咱們要一步步往上拉。
首先把\(splay(N)\)，使之成爲當前Splay中的根。
爲了知足性質2，原來\(N-O\)的重邊要變輕。
由於按深度\(O\)在\(N\)的下面，在Splay中\(O\)在\(N\)的右子樹中，因此直接單方面將\(N\)的右兒子置爲\(0\)（認父不認子）
而後就變成了這樣——

咱們接着把\(N\)所屬Splay的虛邊指向的\(I\)（在原樹上是\(L\)的父親）也轉到它所屬Splay的根，\(splay(I)\)。
原來在\(I\)下方的重邊\(I-K\)要變輕（一樣是將右兒子去掉）。
這時候\(I-L\)就能夠變重了。由於\(L\)確定是在\(I\)下方的（剛纔\(L\)所屬Splay指向了\(I\)），因此I的右兒子置爲\(N\)，知足性質1。
而後就變成了這樣——

\(I\)指向\(H\)，接着\(splay(H)\)，\(H\)的右兒子置爲\(I\)。

\(H\)指向\(A\)，接着\(splay(A)\)，\(A\)的右兒子置爲\(H\)。

\(A-N\)的路徑已經在一個Splay中了，大功告成！
代碼其實很簡單。。。。。。循環處理，只有四步——

1. 轉到根；
2. 換兒子；
3. 更新信息；
4. 當前操做點切換爲輕邊所指的父親，轉1

inline void access(int x){
    for(int y=0;x;y=x,x=f[x])
        splay(x),c[x][1]=y,pushup(x);//兒子變了，須要及時上傳信息
}

\(makeroot(x)\)

只是把根到某個節點的路徑拉起來並不能知足咱們的須要。更多時候，咱們要獲取指定兩個節點之間的路徑信息。
然而必定會出現路徑不能知足按深度嚴格遞增的要求的狀況。根據性質1，這樣的路徑不能在一個Splay中。
Then what can we do?
\(makeroot\)定義爲換根，讓指定點成爲原樹的根。
這時候就利用到\(access(x)\)和Splay的翻轉操做。
\(access(x)\)後\(x\)在Splay中必定是深度最大的點對吧。
\(splay(x)\)後，\(x\)在Splay中將沒有右子樹（性質1）。因而翻轉整個Splay，使得全部點的深度都倒過來了，\(x\)沒了左子樹，反倒成了深度最小的點（根節點），達到了咱們的目的。
代碼

inline void pushr(int x){//Splay區間翻轉操做
    swap(c[x][0],c[x][1]);
    r[x]^=1;//r爲區間翻轉懶標記數組
}
inline void makeroot(int x){
    access(x);splay(x);
    pushr(x);
}

關於pushdown和makeroot的一個相關的小問題詳見下方update（關於pushdown的說明）

\(findroot(x)\)

找\(x\)所在原樹的樹根，主要用來判斷兩點之間的連通性（findroot(x)==findroot(y)代表\(x,y\)在同一棵樹中）
代碼：

inline int findroot(R x){
    access(x); splay(x);
    while(c[x][0])pushdown(x),x=c[x][0];
//如要得到正確的原樹樹根，必定pushdown！詳見下方update（關於findroot中pushdown的說明）
    splay(x);//保證複雜度
    return x;
}

一樣利用性質1，不停找左兒子，由於其深度必定比當前點深度小。

\(split(x,y)\)

神奇的\(makeroot\)已經出現，咱們終於能夠訪問指定的一條在原樹中的鏈啦！
split(x,y)定義爲拉出\(x-y\)的路徑成爲一個Splay（本蒟蒻以\(y\)做爲該Splay的根）
代碼

inline void split(int x,int y){
    makeroot(x);
    access(y);splay(y);
}

x成爲了根，那麼x到y的路徑就能夠用\(access(y)\)直接拉出來了，將y轉到Splay根後，咱們就能夠直接經過訪問\(y\)來獲取該路徑的有關信息

\(link(x,y)\)

連一條\(x-y\)的邊（本蒟蒻使\(x\)的父親指向\(y\)，連一條輕邊）
代碼

inline bool link(int x,int y){
    makeroot(x);
    if(findroot(y)==x)return 0;//兩點已經在同一子樹中，再連邊不合法
    f[x]=y;
    return 1;
}

若是題目保證連邊合法，代碼就能夠更簡單

inline void link(int x,int y){
    makeroot(x);
    f[x]=y;
}

\(cut(x,y)\)

將\(x-y\)的邊斷開。
若是題目保證斷邊合法，卻是很方便。
使\(x\)爲根後，\(y\)的父親必定指向\(x\)，深度相差必定是\(1\)。當\(access(y),splay(y)\)之後，\(x\)必定是\(y\)的左兒子，直接雙向斷開鏈接

inline void cut(int x,int y){
    split(x,y);
    f[x]=c[y][0]=0;
    pushup(y);//少了個兒子，也要上傳一下
}

那若是不必定存在該邊呢？
充分利用好Splay和LCT的各類基本性質吧！
正確姿式——先判一下連通性（注意\(findroot(y)\)之後\(x\)成了根），再看看\(x,y\)是否有父子關係，還要看\(y\)是否有左兒子。
由於\(access(y)\)之後，假如y與x在同一Splay中而沒有直接連邊，那麼這條路徑上就必定會有其它點，在中序遍歷序列中的位置會介於\(x\)與\(y\)之間。
那麼可能\(y\)的父親就不是\(x\)了。
也可能\(y\)的父親仍是\(x\)，那麼其它的點就在\(y\)的左子樹中

只有三個條件都知足，才能夠斷掉。

inline bool cut(int x,int y){
    makeroot(x);
    if(findroot(y)!=x||f[y]!=x||c[y][0])return 0;
    f[y]=c[x][1]=0;//x在findroot(y)後被轉到了根
    pushup(x);
    return 1;
}

若是維護了\(size\)，還能夠換一種判斷

inline bool cut(int x,int y){
    makeroot(x);
    if(findroot(y)!=x||sz[x]>2)return 0;
    f[y]=c[x][1]=0;
    pushup(x);
    return 1;
}

解釋一下，若是他們有直接連邊的話，\(access(y)\)之後，爲了知足性質1，該Splay只會剩下\(x,y\)兩個點了。
反過來講，若是有其它的點，\(size\)不就大於\(2\)了麼？

---

其實，還有一些LCT中的Splay的操做，跟咱們以往學習的純Splay的某些操做細節不甚相同。
包括\(splay(x),rotate(x),nroot(x)\)（看到許多版本LCT寫的是\(isroot(x)\)，但我以爲反過來會方便些）
這些區別之處詳見下面的模板題註釋。

update（關於findroot中pushdown的說明）

蒟蒻真的一時沒注意這個問題。。。。。。Splay根本沒學好
找根的時候，固然不能保證Splay中到根的路徑上的翻轉標記全放掉。
因此最好把pushdown寫上。
Candy巨佬的總結對pushdown問題有詳細的分析
只不過蒟蒻後來常常習慣這樣判連通性（我也不知道怎麼養成的）

makeroot(x);
if(findroot(y)==x)//後續省略

這樣好像沒出過問題，那應該能夠證實是沒問題的（makeroot保證了x在LCT的頂端，access(y)+splay(y)之後，假如x,y在一個Splay裏，那x到y的路徑必定所有放完了標記）
致使好久沒有發現錯誤。。。。。。
另外提一下，假如LCT題目在維護連通性的狀況中只可能出現合併而不會出現分離的話，其實能夠用並查集哦！（實踐證實findroot很慢）
這樣的例子有很多，好比下面「維護鏈上的邊權信息」部分的兩道題都是的。
甚至聽到Julao們說有少許題目還專門卡這個常數。。。。。。XZY巨佬的博客就提到了

update（關於pushdown的說明）

我pushdown和makeroot有時候會這樣寫，常數小一點

void pushdown(int x){
    if(r[x]){
        r[x]=0;
        int t=c[x][0];
        r[c[x][0]=c[x][1]]^=1;
        r[c[x][1]=t]^=1;
    }
}
void makeroot(int x){
    access(x);splay(x);
    r[x]^=1;
}

這種寫法等於說當x有懶標記時，x的左右兒子仍是反的
那麼若是findroot裏實在要寫pushdown，那麼這種pushdown就會出現問題（參考評論區@ zjp_shadow巨佬的指正）
再次update，蒟蒻發現這種問題仍是能夠避免的，若用這種pushdown，findroot這樣寫就好啦

inline int findroot(int x){
    access(x);splay(x);
    pushdown(x);
    while(lc)pushdown(x=lc);
    splay(x);
    return x;
}

當題目中維護的信息與左右兒子順序有關的時候，pushdown若是用這種不嚴謹寫法會是錯的（好比[NOI2005]維護數列（這是Splay題）和洛谷P3613 睡覺困難綜合徵）
再次update，夏丶沐瑾巨佬指出這種問題也是能夠避免的，把pushup這樣寫就好啦

inline void pushup(int x){
    pushdown(lc);pushdown(rc);//加上兩個
    //......
}

因此此總結以及下面模板裏的pushdown，常數大了一點點，倒是更穩妥、嚴謹的寫法

//pushr同上方makeroot部分
void pushdown(int x){
    if(r[x]){
        if(c[x][0])pushr(c[x][0]);//copy自模板，而後發現if能夠不寫
        if(c[x][1])pushr(c[x][1]);
        r[x]=0;
    }
}
void makeroot(int x){
    access(x);splay(x);
    pushr(x);//能夠看到兩種寫法形成makeroot都是不同的
}

這種寫法等於說當x有懶標記時，x的左右兒子已經放到正確的位置了，只是兒子的兒子仍是反的
那麼這樣就不會出問題啦
兩種寫法差異還確實有點大呢

模板

洛谷P3690 【模板】Link Cut Tree （動態樹）（點擊進入題目）
最基本的LCT操做都在這裏，也沒有更多額外的複雜操做了，確實很模板。

#include<bits/stdc++.h>
#define R register int
#define I inline void
#define G if(++ip==ie)if(fread(ip=buf,1,SZ,stdin))
#define lc c[x][0]
#define rc c[x][1]
using namespace std;
const int SZ=1<<19,N=3e5+9;
char buf[SZ],*ie=buf+SZ,*ip=ie-1;
inline int in(){
    G;while(*ip<'-')G;
    R x=*ip&15;G;
    while(*ip>'-'){x*=10;x+=*ip&15;G;}
    return x;
}
int f[N],c[N][2],v[N],s[N],st[N];
bool r[N];
inline bool nroot(R x){//判斷節點是否爲一個Splay的根（與普通Splay的區別1）
    return c[f[x]][0]==x||c[f[x]][1]==x;
}//原理很簡單，若是連的是輕邊，他的父親的兒子裏沒有它
I pushup(R x){//上傳信息
    s[x]=s[lc]^s[rc]^v[x];
}
I pushr(R x){R t=lc;lc=rc;rc=t;r[x]^=1;}//翻轉操做
I pushdown(R x){//判斷並釋放懶標記
    if(r[x]){
        if(lc)pushr(lc);
        if(rc)pushr(rc);
        r[x]=0;
    }
}
I rotate(R x){//一次旋轉
    R y=f[x],z=f[y],k=c[y][1]==x,w=c[x][!k];
    if(nroot(y))c[z][c[z][1]==y]=x;c[x][!k]=y;c[y][k]=w;//額外注意if(nroot(y))語句，此處不判斷會引發致命錯誤（與普通Splay的區別2）
    if(w)f[w]=y;f[y]=x;f[x]=z;
    pushup(y);
}
I splay(R x){//只傳了一個參數，由於全部操做的目標都是該Splay的根（與普通Splay的區別3）
    R y=x,z=0;
    st[++z]=y;//st爲棧，暫存當前點到根的整條路徑，pushdown時必定要從上往下放標記（與普通Splay的區別4）
    while(nroot(y))st[++z]=y=f[y];
    while(z)pushdown(st[z--]);
    while(nroot(x)){
        y=f[x];z=f[y];
        if(nroot(y))
            rotate((c[y][0]==x)^(c[z][0]==y)?x:y);
        rotate(x);
    }
    pushup(x);
}
/*固然了，其實利用函數堆棧也很方便，代替上面的手工棧，就像這樣
I pushall(R x){
    if(nroot(x))pushall(f[x]);
    pushdown(x);
}*/
I access(R x){//訪問
    for(R y=0;x;x=f[y=x])
        splay(x),rc=y,pushup(x);
}
I makeroot(R x){//換根
    access(x);splay(x);
    pushr(x);
}
int findroot(R x){//找根（在真實的樹中的）
    access(x);splay(x);
    while(lc)pushdown(x),x=lc;
    splay(x);
    return x;
}
I split(R x,R y){//提取路徑
    makeroot(x);
    access(y);splay(y);
}
I link(R x,R y){//連邊
    makeroot(x);
    if(findroot(y)!=x)f[x]=y;
}
I cut(R x,R y){//斷邊
    makeroot(x);
    if(findroot(y)==x&&f[y]==x&&!c[y][0]){
        f[y]=c[x][1]=0;
        pushup(x);
    }
}
int main()
{
    R n=in(),m=in();
    for(R i=1;i<=n;++i)v[i]=in();
    while(m--){
        R type=in(),x=in(),y=in();
        switch(type){
        case 0:split(x,y);printf("%d\n",s[y]);break;
        case 1:link(x,y);break;
        case 2:cut(x,y);break;
        case 3:splay(x);v[x]=y;//先把x轉上去再改，否則會影響Splay信息的正確性
        }
    }
    return 0;
}