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;
}