LA-3961-Robotic Sort(FHQTreap版)

题目链接： LA-3961-Robotic Sort

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

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

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

样例输入：

6
3 4 5 1 6 2
4
3 3 2 1
0

样例输出：

4 6 4 5 6 6
4 2 4 4

题目分析：
这道题需要在每次操作时找到区间最小值，但由于会被放到最前面，所以我们可以默认最小值在翻转后被删除，所以要维护的就是全局最小值和全局最小值的位置(注意要把删掉的数加回去)，因为有可能有相同的数，而题目要求相同的数要把在原序列中先出现的排在后出现的前面，因此可以先处理一下保证每个位置的数字值不相同，然后再加一个找最小值位置的函数$find$_$min$ _ $pos$，翻转操作就是常规的操作了。代码如下：

题目代码：

#include<stdio.h>
#include<algorithm>
#include<string.h>
#include<time.h>
#define mxn 100005
using namespace std;
int rt,sz;
struct Arr{
	int val,pos,_val;
}arr[mxn];
bool cmp(Arr a,Arr b){
	if(b.val^a.val)return a.val<b.val;
	else return a.pos<b.pos;
}
bool cmp_(Arr a,Arr b){
	return a.pos<b.pos;
}
struct Node{
	int lson,rson;
	int size,val,pri;
	int minn,tag;
}T[mxn];

int new_node(int v){
	T[++sz].size=1;
	T[sz].minn=T[sz].val=v;
	T[sz].lson=T[sz].rson=T[sz].tag=0;
	T[sz].pri=rand();
	return sz;
}
void reverse(int k){
	if(!k)return;
	swap(T[k].lson,T[k].rson);
	T[k].tag^=1;
}

void pushdown(int k){
	if(!k)return;
	if(T[k].tag){
		reverse(T[k].lson);
		reverse(T[k].rson);
		T[k].tag=0;
	}
}
void pushup(int k){
	if(!k)return;
	T[k].size=T[T[k].lson].size+T[T[k].rson].size+1;
	if(T[k].lson&&T[k].rson)
		T[k].minn=min(T[k].val,min(T[T[k].lson].minn,T[T[k].rson].minn));
	if(!T[k].lson&&T[k].rson)
		T[k].minn=min(T[k].val,T[T[k].rson].minn);
	if(!T[k].rson&&T[k].lson)
		T[k].minn=min(T[k].val,T[T[k].lson].minn);
	if(!T[k].lson&&!T[k].rson)
		T[k].minn=T[k].val;
}
void split(int now,int k,int &x,int &y){
	if(!now){x=y=0;return;}
	else{
		pushdown(now);
		if(k<=T[T[now].lson].size)
			y=now,split(T[now].lson,k,x,T[now].lson);
		else x=now,split(T[now].rson,k-T[T[now].lson].size-1,T[now].rson,y);
		pushup(now);
	}
}
int merge(int x,int y){
	if(!x||!y)return x+y;
	if(T[x].pri<T[y].pri){
		pushdown(x);
		T[x].rson=merge(T[x].rson,y);
		pushup(x);
		return x;
	}
	else{
		pushdown(y);
		T[y].lson=merge(x,T[y].lson);
		pushup(y);
		return y;
	}
}
int build(int l,int r){
	if(l==r)return new_node(arr[l]._val);
	int mid=(l+r)>>1;
	int x=build(l,mid),y=build(mid+1,r);
	return merge(x,y);
	
}
void DFS(int k){
	if(!k)return;
	pushdown(k);
	DFS(T[k].lson);
	printf("%d ",T[k].val);
	DFS(T[k].rson);
}
int find_min_pos(int k,int v){
	if(!k)return 0;
	pushdown(k);
	if(T[T[k].lson].minn==v)
		return find_min_pos(T[k].lson,v);
	else if(T[k].val==v)return T[T[k].lson].size+1;
	else if(T[T[k].rson].minn==v)
		return find_min_pos(T[k].rson,v)+T[T[k].lson].size+1;
}
int main()
{
	srand(time(0));
	int n,bf=0;
	while(scanf("%d",&n)&&n){
		sz=0;rt=0;
		for(int i=1;i<=mxn-5;i++)
			T[i].minn=0x7ffffff;
		for(int i=1;i<=n;i++){
			scanf("%d",&arr[i].val);
			arr[i].pos=i;
		}
		sort(arr+1,arr+n+1,cmp);
		for(int i=1;i<=n;i++)arr[i]._val=i;
		sort(arr+1,arr+n+1,cmp_);
		rt=build(1,n);
		for(int i=1;i<=n;i++){
			int x,y,z;
			int pos=find_min_pos(rt,T[rt].minn);
			if(i^n)printf("%d ",pos+i-1);
			else printf("%d\n",pos+i-1);
			split(rt,pos,x,y);
			split(x,pos-1,x,z);
			reverse(x);
			rt=merge(x,y);
		}
	}
	return 0;
}