HDU 4441 Queue Sequence（12年天津现场，Splay+线段树）
转载请注明出处，谢谢http://blog.csdn.net/ACM_cxlove?viewmode=contents by---cxlove
题目：每次有三种操作
insert pos 表示在pos插入一个数，这个数是最小的正数没有在序列中出现的。而且还要在某个位置插入他的相反数
remove num 表示把num以及-num去掉
query num 把num与-num之间的数求和输出
http://acm.hdu.edu.cn/showproblem.php?pid=4441
首先说一下insert操作
对于需要插入的那个数，维护一个线段树表示区间最值就OK了，随意搞吧。
那么对于插入的正数，位置已经告诉了，就简单了，对于那个负数，要求的位置是最右边的满足条件的。
其实题目要求的就是正数的顺序和负数的是一样的。
那么如果当前数字i前面有n个正数，那么表示-i前面也有n个负数，而且又需要是最右边的
就是第 n+1个负数的左边，如果没有n+1个负数，那就看插到最后（所以代码中有一个判断）
那么怎么找第n+1个负数呢，只需要维护一个值，表示负数的个数就行了，我还维护了正数有多少个，其实没啥用，TAT
然后是remove操作，只要记录num以及-num在Splay中的编号就可以了。
那么 就可以很轻松的通过编号找到结点，删除
我存的是编号，那么在删除的时候，先旋转至根，找到他的左边有多少个数，这样得到他的位置，就好处理了
最后是query操作，由于 我们存了编号
那么通过Splay很快能找到中间的区间，维护一个区间和就OK了
这种数据结构题，代码量很大，给现场短时候1A的队伍跪烂啊，需要非常注意细节。
写代码的时候简单地加了点注释
#include<iostream>
#include<cstdio>
#include<map>
#include<cstring>
#include<cmath>
#include<vector>
#include<algorithm>
#include<set>
#include<string>
#include<queue>
#define inf 1<<30
#define M 200005
#define N 200005
#define maxn 300005
#define eps 1e-10
#define zero(a) fabs(a)<eps
#define Min(a,b) ((a)<(b)?(a):(b))
#define Max(a,b) ((a)>(b)?(a):(b))
#define pb(a) push_back(a)
#define mp(a,b) make_pair(a,b)
#define mem(a,b) memset(a,b,sizeof(a))
#define LL long long
#define lson step<<1
#define rson step<<1|1
#define MOD 1000000009
#define sqr(a) ((a)*(a))
#define Key_value ch[ch[root][1]][0]
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
struct Splay_tree{
LL sum[N];
int size[N],pre[N],val[N],tot;
int ch[N][2],tot1,root,s[N],tot2,cnt[N][2]; //cnt[0]表示的是正数个数，cnt[1]表示的是负数个数
//debug部分copy from hh
void Treaval(int x) {
if(x) {
Treaval(ch[x][0]);
printf("结点%2d:左儿子 %2d 右儿子 %2d 父结点 %2d size = %2d ,val = %2c \n",x,ch[x][0],ch[x][1],pre[x],size[x],val[x]);
Treaval(ch[x][1]);
}
}
void debug() {printf("%d\n",root);Treaval(root);}
//以上Debug
inline void NewNode(int &r,int k,int father){
r=++tot1;
ch[r][0]=ch[r][1]=0;
cnt[r][0]=k>0;
cnt[r][1]=k<0;
sum[r]=k;
pre[r]=father;
size[r]=1;
val[r]=k;
}
inline void Push_Up(int x){
if(x==0) return ;
int l=ch[x][0],r=ch[x][1];
size[x]=size[l]+size[r]+1;
cnt[x][0]=cnt[l][0]+cnt[r][0]+(val[x]>0);
cnt[x][1]=cnt[l][1]+cnt[r][1]+(val[x]<0);
sum[x]=(LL)sum[l]+sum[r]+val[x];
}
inline void Init(){
tot1=tot2=root=tot=0;
ch[root][0]=ch[root][1]=pre[root]=size[root]=sum[0]=cnt[0][0]=cnt[0][1]=0;
val[root]=0;
NewNode(root,0,0);
NewNode(ch[root][1],0,root);
Push_Up(ch[root][1]);
Push_Up(root);
}
inline void Rotate(int x,int kind){
int y=pre[x];
ch[y][!kind]=ch[x][kind];
pre[ch[x][kind]]=y;
if(pre[y])
ch[pre[y]][ch[pre[y]][1]==y]=x;
pre[x]=pre[y];
ch[x][kind]=y;
pre[y]=x;
Push_Up(y);
}
inline void Splay(int r,int goal){
while(pre[r]!=goal){
if(pre[pre[r]]==goal)
Rotate(r,ch[pre[r]][0]==r);
else{
int y=pre[r];
int kind=(ch[pre[y]][0]==y);
if(ch[y][kind]==r){
Rotate(r,!kind);
Rotate(r,kind);
}
else{
Rotate(y,kind);
Rotate(r,kind);
}
}
}
Push_Up(r);
if(goal==0) root=r;
}
inline void RotateTo(int k, int goal) {
int x=root;
while(k!=size[ch[x][0]]+1){
if (k<=size[ch[x][0]]){
x=ch[x][0];
}else{
k-=(size[ch[x][0]]+1);
x=ch[x][1];
}
}
Splay(x,goal);
}
inline int Get_Kth(int r,int k){
int t=size[ch[r][0]]+1;
if(t==k) return r;
if(t>k) return Get_Kth(ch[r][0],k);
else return Get_Kth(ch[r][1],k-t);
}
inline int Insert(int pos,int k){
tot++;
RotateTo(pos,0);
RotateTo(pos+1,root);
NewNode(Key_value,k,ch[root][1]);
Push_Up(ch[root][1]);
Push_Up(root);
return Key_value;
}
inline void Delete(int r){
tot--;
Splay(r,0);
int pos=size[ch[r][0]];
RotateTo(pos,0);
RotateTo(pos+2,root);
s[tot2++]=Key_value;
Key_value=0;
Push_Up(ch[root][1]);
Push_Up(root);
}
//找第n+1个负数的位置
inline int find(int x,int n){
int l=ch[x][0],r=ch[x][1];
if(cnt[l][1]==n&&val[x]<0) {Splay(x,0);return size[ch[root][0]];}
else if(cnt[l][1]>=n+1) return find(l,n);
else return find(r,n-cnt[l][1]-(val[x]<0));
}
inline void InOrder(int r){
if(r==0)
return;
InOrder(ch[r][0]);
printf("%d ",val[r]);
InOrder(ch[r][1]);
}
inline void Print(){
RotateTo(1,0);
RotateTo(tot+2,root);
InOrder(Key_value);
printf("\n");
}
}splay;
struct Segment_tree{
int left,right,mmin;
}L[N*4];
int position[N][2];
void Push_Up(int step){
L[step].mmin=min(L[lson].mmin,L[rson].mmin);
}
void Bulid(int step,int l,int r){
L[step].left=l;
L[step].right=r;
if(l==r){
L[step].mmin=l;
return;
}
int m=(l+r)/2;
Bulid(lson,l,m);
Bulid(rson,m+1,r);
Push_Up(step);
}
//flag为1表示是插入，flag为0表示是删除
void Update(int step,int pos,int flag){
if(L[step].left==pos&&pos==L[step].right){
if(flag) L[step].mmin=inf;
else L[step].mmin=L[step].left;
return ;
}
int m=(L[step].left+L[step].right)/2;
if(pos<=m) Update(lson,pos,flag);
else Update(rson,pos,flag);
Push_Up(step);
}
void Insert(int pos){
int num=L[1].mmin;
position[num][0]=splay.Insert(pos+1,num);
splay.Splay(position[num][0],0);
int n=splay.cnt[splay.ch[splay.root][0]][0]; //表示在+i之前有多少个正数
//将-i插入到第n+1个负数左边
if(splay.cnt[splay.root][1]<=n){
int m=splay.size[splay.root]-2+1;
position[num][1]=splay.Insert(m,-num);
Update(1,num,1); //插入线段树
}
else{
int m=splay.find(splay.root,n); //表示第n+1个负数是第m个数
position[num][1]=splay.Insert(m,-num);
Update(1,num,1); //插入线段树
}
}
void Remove(int k){
splay.Delete(position[k][0]);
splay.Delete(position[k][1]);
Update(1,k,0); //从线段树中移除
}
LL Query(int k){
splay.Splay(position[k][0],0);
splay.Splay(position[k][1],splay.root);
return splay.sum[splay.ch[splay.ch[splay.root][1]][0]];
}
int main(){
int cas=0,q;
while(scanf("%d",&q)!=EOF){
printf("Case #%d:\n",++cas);
splay.Init();
Bulid(1,1,q);
while(q--){
char str[10];int k;
scanf("%s%d",str,&k);
if(str[0]=='i') Insert(k);
else if(str[0]=='r') Remove(k);
else printf("%I64d\n",Query(k));
// splay.Print();
}
}
return 0;
}