Splay 模板 BZOJ 1552/3506 robotic sort

bzoj 1552/3506 robotic sort

Description

Input

输入共两行，第一行为一个整数N，N表示物品的个数，1<=N<=100000。第二行为N个用空格隔开的正整数，表示N个物品最初排列的编号。
Output

输出共一行，N个用空格隔开的正整数P1,P2,P3…Pn，（1 < = Pi < = N），Pi表示第i次操作前第i小的物品所在的位置。 注意：如果第i次操作前，第i小的物品己经在正确的位置Pi上，我们将区间[Pi,Pi]反转(单个物品)。

Sample Input

6
3 4 5 1 6 2

Sample Output

4 6 4 5 6 6

思路：
一看要反转，就想到Splay了，我们要反转的是下标，所以我们就去维护下标，这样就会出现一个问题，我们如何去找第k大的物品在哪里呢？于是我们考虑多一个min的域，用来维护区间内的最小值物品下标。（由于物品权值可能重复，所以先来一次离散化）

区间反转操作的详述

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<cmath>
#define pa pair<int,int>
#define inf 1000000000
#define ll long long 
using namespace std;

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

const int N = 100010;

int n, root, top;
int ans[N], s[N], mn[N];

struct goods{
    int pos, v;
}a[N];

bool cmp_rnk(goods a, goods b){return a.v < b.v || (a.v == b.v && a.pos < b.pos);}
bool cmp_bck(goods a, goods b){return a.pos < b.pos;}

struct Node{  
    int ch[2], fa, v, size, mnpos;  
    bool rv;//是否翻转，因为偶数次翻转无效，所以可以用bool，位运算 
    void set(int x){v=x; ch[0]=ch[1]=fa=rv=0; size=1;}  
}tr[N];

void update(int x){
    if( !x ) return;//
    mn[x] = tr[x].v; tr[x].mnpos = x;
    if(mn[lson] < mn[x]){mn[x] = mn[lson]; tr[x].mnpos = tr[lson].mnpos;}//更新最小值 
    if(mn[rson] < mn[x]){mn[x] = mn[rson]; tr[x].mnpos = tr[rson].mnpos;}
    tr[x].size = tr[lson].size + tr[rson].size + 1;
}

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;//当前层翻转 
    }
}

void rotate(int x, int &k){
    int fa = tr[x].fa, ffa = tr[fa].fa;
    int l = (tr[fa].ch[0] != x);
    int r = l ^ 1;
    if(fa == k) k = x;//
    else {
        if(tr[ffa].ch[0] == fa)
            tr[ffa].ch[0] = x;
        else tr[ffa].ch[1] = x;
    }
    tr[x].fa = ffa; tr[fa].fa = x; tr[tr[x].ch[r]].fa = fa;
    tr[fa].ch[l] = tr[x].ch[r]; tr[x].ch[r] = fa;
    update(fa); update(x);
}

void splay(int x, int &k){
    top = 0; s[++top] = x;
    for(int i=x; tr[i].fa; i=tr[i].fa)
        s[++top] = tr[i].fa;
    for(int i=top; i; i--) pushdown(s[i]);
    while(x != k){
        int fa =tr[x].fa, ffa = tr[fa].fa;
        if(fa != k){
            if(tr[fa].ch[0] == x ^ tr[ffa].ch[0] == fa)//Z字形（由于旋上去自动就会降深度，所以就是普通旋转）
                rotate(x, k);//与fa形成一条链（链状是一种不优的状态，所以通过先旋fa再旋x的方式降深度） 
            else rotate(fa, k);
        }
        rotate(x, k);//离目标位置只有一步
    }
}

int find(int x, int rk){//rk表示区间内第rk大的数 
    pushdown(x);//标记下传 
    if(tr[lson].size + 1 == rk) return x;
    else if(tr[lson].size >= rk) return find(lson, rk);
    else return find(rson, rk-tr[lson].size-1);
}

int qumin(int L, int R){
    int x = find(root,L), y = find(root,R+2);//根据下标找树中的位置（因为是依靠下标建的树有BST的性质） 
    splay(x,root); splay(y,tr[x].ch[1]);//把区间左端的左一个位置转到root，把区间右端的右一个位置转到root的rson
    //于是根据BST的性质，我们要找的区间就在root的rson的lson上。（这个操作就是把区间归拢到一起） 
    int z = tr[y].ch[0];
    return tr[z].mnpos;//这样就找到了该区间内权值最小的物品的下标，也就是我们要翻转的右端点 
}

void rever(int L, int R){
    int x=find(root,L), y=find(root,R+2);//R
    splay(x,root); splay(y,tr[x].ch[1]);
    int z = tr[y].ch[0];//z统领要标记的区间
    tr[z].rv ^= 1;
}

void build(int l, int r, int fa){
    if(l > r) return;
    if( l == r ){
        tr[l].fa = fa;
        tr[l].size = 1;
        mn[l] = tr[l].v = a[l].v;//mn维护区间min 
        tr[l].mnpos = l;//mnpos维护min的下标 
        if(l < fa) tr[fa].ch[0] = l;
        else tr[fa].ch[1] = l;
        return;
    }
    int mid = (l + r) >> 1;
    build(l, mid-1, mid); build(mid+1, r, mid);
    tr[mid].fa = fa;
    tr[mid].v = a[mid].v;
    update(mid);
    if(mid < fa) tr[fa].ch[0] = mid;
    else tr[fa].ch[1] = mid;
}

int main(){
    scanf("%d", &n);
    a[1].v=a[n+2].v=inf; mn[0]=inf;//边界 
    for(int i=2; i<=n+1; i++){
        scanf("%d", &a[i].v);
        a[i].pos = i;
    }
    sort(a+2, a+n+2, cmp_rnk);
    for(int i=2; i<=n+1; i++)
        a[i].v = i - 1;//离散化 
    sort(a+2, a+n+2, cmp_bck);//按照下标排序 
    build(1, n+2, 0);
    root = (n + 3) >> 1;//root取中点，保证深度的优越 
    for(int i=1; i<=n; i++){
        int x = qumin(i, n);//n+2
        //我们要找的这个权值第i大的物品一定在下标为【i+1，n+1】的区间内（不要忘记1和n+2两个我们认为加上去的点）。（前面的i-1次操作保证了前i-1个位置的有序） 
        //也就是说我们要找【i+1，n+1】的区间内权值最小的一个物品的下标。（因为我们的翻转操作就是针对下标进行的） 
        splay(x, root);//把x->转到root 
        ans[i] = tr[tr[x].ch[0]].size;//有一个边界点1 
        rever(i, ans[i]);//标记翻转【i+1，ans[i+1]】 
    }
    for(int i=1; i<n; i++){
        printf("%d ", ans[i]);
    }
    printf("%d", ans[n]);
    return 0;
}