bzoj 3506[Cqoi2014]排序机械臂

　　　　　　　　3506: [Cqoi2014]排序机械臂

题目描述

为了把工厂中高低不等的物品按从低到高排好序，工程师发明了一种排序机械臂。它遵循一个简单的排序规则，第一次操作找到高度最低的物品的位置 P_1P1​ ，并把左起第一个物品至 P_1P1​ 间的物品 (即区间 [1,P_1][1,P1​] 间的物品) 反序；第二次找到第二低的物品的位置 P_2P2​ ，并把左起第二个至 P_2P2​ 间的物品 (即区间 [2,P_2][2,P2​] 间的物品) 反序……最终所有的物品都会被排好序。

上图给出有六个物品的示例，第一次操作前，高度最低的物品在位置 44 ，于是把第一至第四的物品反序；第二次操作前，第二低的物品在位罝六，于是把第二至六的物品反序……

你的任务便是编写一个程序，确定一个操作序列，即每次操作前第 ii 低的物品所在位置 P_iPi​ ，以便机械臂工作。需要注意的是，如果有高度相同的物品，必须保证排序后它们的相对位置关系与初始时相同。

输入输出格式

输入格式：

第一行包含正整数n,表示需要排序的物品数星。

第二行包含n个空格分隔的整数ai,表示每个物品的高度。

输出格式：

输出一行包含n个空格分隔的整数Pi。

输入输出样例

输入样例#1：

6
3 4 5 1 6 2

输出样例#1： 

4 6 4 5 6 6

HINT

N<=100000

Pi<=10^7

维护一个数列，支持区间翻转，所以可以用SPLAY来维护

我们可以先将数排序，这样他们节点数组的下标对应的就是排名

然后就是区间翻转的操作

注意SPLAY的时候要先pushdown

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#define LL long long
#define lc t[x].ch[0] 
#define rc t[x].ch[1]
using namespace std;

const int MAXN = 2e5 + 10;

LL ans = 0;
int sum = 0;
int n;
int root;
int loc[MAXN];
struct node {
    int size;
    int val;
    int id;
    int fa;
    int ch[2];
    int lazy;
} t[MAXN];

void pushdown(int x)
{
    if(t[x].lazy) {
        swap(lc, rc);
        t[lc].lazy ^= 1;
        t[rc].lazy ^= 1;
        t[x].lazy ^= 1;
    }
}

void pushup(int x)
{
    t[x].size = t[lc].size + t[rc].size + 1;
}
inline LL read()
{
    LL x = 0, w = 1; char ch = 0;
    while(ch < '0' || ch > '9') {
        if(ch == '-') {
            w = -1;
        }
        ch = getchar();
    }
    while(ch >= '0' && ch <= '9') {
        x = x * 10 + ch - '0';
        ch = getchar();
    }
    return x * w;
}

void rotate(int x, int &k)
{
    int y = t[x].fa, z = t[y].fa;
    int l, r;
    if(y == k) {
        k = x;
    } else {
        if(t[z].ch[0] == y) {
            t[z].ch[0] = x;
        } else {
            t[z].ch[1] = x;
        }
    }
    if(t[y].ch[0] == x) {
        l = 0;
    } else {
        l = 1;
    }
    r = l ^ 1;
    t[y].ch[l] = t[x].ch[r], t[t[x].ch[r]].fa = y;
    t[x].fa = z, t[y].fa = x, t[x].ch[r] = y;
    pushup(y);
    pushup(x);
}

void splay(int x, int &k)
{
    while(x != k) {
        int y = t[x].fa, z = t[y].fa;
        if(y != k) {
            if((t[z].ch[0] == y) ^ (t[y].ch[0] == x)) {
                rotate(x, k);
            } else {
                rotate(y, k);
            }
        }
        rotate(x, k);
    }
}

int query(int k, int x)
{
    pushdown(x);
    while(t[lc].size + 1 != k) {
        if(t[lc].size >= k) {
            x = lc;    
        } else {
            k = k - t[lc].size - 1;
            x = rc;
        }
        pushdown(x);
    }
    return x;
}

bool cmp(node a, node b)
{
    if(a.val == b.val) {
        return a.id < b.id;
    }
    return a.val < b.val;
}

void build(int l, int r, int &x, int last)
{
    if(l > r) {
        x = 0;
        return;
    }
    int mid = (l + r) >> 1;
    x = loc[mid];
    t[x].fa = last;
    build(l, mid - 1, lc, x);
    build(mid + 1, r, rc, x);
    pushup(x);
}

void push(int x)
{
    int sum = 0;
    if(t[x].fa) {
        push(t[x].fa);
        pushdown(x);
    }
}

void print(int x)
{
    cout<<x<<" "<<t[x].size<<" "<<lc<<" "<<rc<<endl;
    if(lc) {
        print(lc);
    }
    if(rc) {
        print(rc);
    }
}

int main()
{
    n = read();
    for(int i = 1; i <= n; i++) {
        t[i].id = i;
        t[i].val = read();
    }
    sort(t + 1, t + n + 1, cmp);
    for(int i = 1; i <= n; i++) {
        loc[t[i].id] = i;
    }
    loc[0] = n + 2, loc[n + 1] = n + 1;
    build(0, n + 1, root, 0);
    for(int i = 1; i <= n; i++) {
        push(i);
        splay(i, root);
        ans = t[t[root].ch[0]].size;
        printf("%lld ", ans);
        int loc = query(i, root);
        splay(loc, root);
        loc = query(ans + 2, root);
        splay(loc, t[root].ch[1]);
        t[t[loc].ch[0]].lazy ^= 1;
    }
    return 0;
}


/*
6
3 4 5 1 6 2

*/