【bzoj3223】Tyvj 1729 文藝平衡樹

Description
您需要寫一種資料結構（可參考題目標題），來維護一個有序數列，其中需要提供以下操作：翻轉一個區間，例如原有序序列是5 4 3 2 1，翻轉區間是[2,4]的話，結果是5 2 3 4 1

Input
第一行為n,m n表示初始序列有n個數，這個序列依次是(1,2……n-1,n) m表示翻轉操作次數 接下來m行每行兩個數[l,r] 資料保證 1<=l<=r<=n

Output
輸出一行n個數字，表示原始序列經過m次變換後的結果

Sample Input
5 3
1 3
1 3
1 4

Sample Output
4 3 2 1 5

HINT
N,M<=100000

思路
區間翻轉問題
翻轉區間->交換BST的左右子樹（逐層交換，正確性請自行驗證），區間標記降低翻轉次數
尋找要操作的區間[l,r]：將當前排名（size）為l的節點（節點l-1）轉到根，將當前排名為r+2的節點（節點r+1）轉到根的右子樹的根節點，則根的右子樹的根節點的左子樹為所求區間，直接標記該區間就可以了。（類似線段樹區間修改）
splay操作維護一棵較優的樹，三種方式進行旋轉操作。

注意
1.標記是在每一次訪問到一個新的節點是就要pushdown的（改變樹的結構會破壞標記區間，所以先一步下傳標記）
2.區分一個節點的排名和這個節點的值：這個節點的排名是它是當前陣列中的第幾個，用左兒子的size+1表示；這個節點的值是題目中輸入的數字，在本題中是1~n
3.增加數字為0和n+1的兩個哨兵節點，因為如果對區間1~x或x~n操作，用到前後的節點就需要0和n+1。
4.有些讀者會疑惑，難道交換左右子樹不會破壞BST的性質嗎？這就是容易混淆的一點，我們的區間操作是根據下標翻轉的，用陣列實現時下標就是陣列地址，子樹交換時，只是儲存內容的改變，下標位置（樹的形狀）只會在旋轉時改變，保證BST性質。

#include <iostream>  
#include <cstdio>  
#include <cstring>  
#include <cstdlib>  
using namespace std;  

const int MAXN = 100010;
const int INF = 0x7fffffff;

#define lson tr[x].ch[0]  
#define rson tr[x].ch[1]

struct Node{  
    int ch[2], fa, v, size;  
    bool rv;//是否翻轉，因為偶數次翻轉無效，所以可以用bool，位運算 
 

    void set(int x){v=x; ch[0]=ch[1]=fa=rv=0; size=1;}  
}tr[MAXN];

int n, m, root, tot, l, r, x1, x2;  

void updata(int x){//維護size 
    if( !x ) return;  
    tr[x].size = 1 + tr[lson].size + tr[rson].size;
}

void pushdown(int x){//打標記必備
    if( !x ) return;  
    if( tr[x].rv ){//x的子節點集合為翻轉區間 
        tr[lson].rv ^= 1; tr[rson].rv ^= 1;//標記下傳 
        tr[x].rv = 0;//消除 
        int t = lson; lson = rson; rson = t;//當前層翻轉 
    }
}

inline bool son(int x) {return tr[tr[x].fa].ch[1] == x;}//判斷ls,rs 

void link(int x, int y, bool cc){//建立x與y的新關係 
    tr[x].ch[cc] = y; tr[y].fa = x;  
}

void rotate(int x){//一種重新連邊似的旋轉方式 
    int fa = tr[x].fa, ffa = tr[fa].fa, tt = son(x);
    link(ffa,x,son(fa)); link(fa,tr[x].ch[!tt],tt); link(x,fa,!tt);  
    updata(fa);
}

void splay(int x, int f){
    pushdown(x);  
    if(f == 0) root = x;//l-1到root
    while(tr[x].fa != f){//到目標位置 
        if (tr[tr[x].fa].fa == f) {rotate(x); break;}//離目標位置只有一步 
        if (son(x) == son(tr[x].fa)) {rotate(tr[x].fa); rotate(x);}//與fa形成一條鏈（鏈狀是一種不優的狀態，所以通過先旋fa再旋x的方式降深度） 
        else {rotate(x); rotate(x);}//Z字形（由於旋上去自動就會降深度，所以就是普通旋轉） 
    }
    updata(x);
}

int build(int l, int r){  
    if(l>r) return 0;  
    int x = ++tot;  
    int mid = (l+r) >> 1;  
    tr[x].set(mid);
    lson = build(l, mid-1);  
    rson = build(mid+1, r);  
    tr[lson].fa = tr[rson].fa = x;  
    updata(x);
    return x;  
}

int find(int x, int y){
    pushdown(x);//有標記就必須pushdown，且寫成遞迴的形式  
    if (tr[lson].size+1 < y) return find(rson, y-tr[lson].size-1);  
    else if(tr[lson].size+1 == y) return x;
    else return find(lson, y);  
}

void dfs(int x){  
    pushdown(x);//標記在每一次訪問之前都要pushdown 
    if(tr[x].ch[0]) dfs(tr[x].ch[0]);
    if(tr[x].v<=n && tr[x].v>=1)  
        cout<<tr[x].v<<' ';
    if(tr[x].ch[1]) dfs(tr[x].ch[1]);  
}

int main(){  
    scanf("%d%d", &n, &m);  
    tot = root = 0;  
    tr[0].v = tr[n+1].v = INF;
    root = build(0, n+1);//0和n+1哨兵節點  
    while(m--){
        scanf("%d%d", &l, &r);
        x1 = find(root, l); x2 = find(root, r+2);//找到l-1，r+1的下標（因為有一個邊界0，所以第l個數其實是l-1，第r+2個數是r-1） 
        splay(x1,0); splay(x2,x1); updata(root);//旋轉l-1到root,r+1到root->rs,標記位置為root->rs->ls此位置及其以下的內容就是l~r 
        tr[tr[x2].ch[0]].rv ^= 1;
        updata(tr[x2].ch[0]); updata(x2); updata(root);
    }  
    dfs(root);//中序遍歷 
    return 0;
}