BZOJ4923:[Lydsy1706月赛]K小值查询(Splay)

Description

维护一个长度为n的正整数序列a_1,a_2,...,a_n，支持以下两种操作：

1 k，将序列a从小到大排序，输出a_k的值。

2 k，将所有严格大于k的数a_i减去k。

Input

第一行包含两个正整数n,m(1<=n,m<=100000)，分别表示序列的长度和操作的个数。

第二行包含n个正整数a_1,a_2,...,a_n(1<=a_i<=10^9)，分别表示序列中的每个元素。

接下来m行，每行两个正整数op(1<=op<=2),k，若op=1，则1<=k<=n；若op=2，则1<=k<=10^9；依次描述每个操作。

Output

输出若干行，对于每个询问输出一行一个整数，即第k小的值。

Sample Input

4 5
1 5 6 12
2 5
1 1
1 2
1 3
1 4

Sample Output

1
1
5
7

Solution

把数排个序然后建$Splay$，每次修改对值域为$[1,k]$中的不管，$[k+1,k\times 2]$中的拆出来改完了再暴力插回去，对于$[k\times 2+1,MAX]$中打标记。我也不知道为什么复杂度是对的。

以后别有事没事把标记下传到$0$点，修改着修改着$0$下标的值就不知道被修改成什么鬼畜的数了。

Code

 #include<iostream>
 #include<cstdio>
 #include<algorithm>
 #define N (100009)
 using namespace std;

 int n,m,opt,k,a[N];
 int Root,Father[N],Son[N][];
 int Val[N],Size[N],Max[N],Add[N];

 int Get(int x) {return Son[Father[x]][]==x;}

 void Pushup(int x)
 {
     Size[x]=Size[Son[x][]]+Size[Son[x][]]+;
     Max[x]=max(Val[x],max(Max[Son[x][]],Max[Son[x][]]));
 }

 int Build(int fa,int l,int r)
 {
     if (l>r) return ;
     int mid=(l+r)>>;
     Father[mid]=fa; Val[mid]=a[mid];
     Son[mid][]=Build(mid,l,mid-);
     Son[mid][]=Build(mid,mid+,r);
     Pushup(mid); return mid;
 }

 void Rotate(int x)
 {
     int wh=Get(x);
     int fa=Father[x],fafa=Father[fa];
     if (fafa) Son[fafa][Son[fafa][]==fa]=x;
     Father[fa]=x; Son[fa][wh]=Son[x][wh^];
     if (Son[fa][wh]) Father[Son[fa][wh]]=fa;
     Father[x]=fafa; Son[x][wh^]=fa;
     Pushup(fa); Pushup(x);
 }

 void Pushdown(int x)
 {
     if (Add[x]!=)
     {
         if (Son[x][])
         {
             Val[Son[x][]]+=Add[x];
             Add[Son[x][]]+=Add[x];
             Max[Son[x][]]+=Add[x];
         }
         if (Son[x][])
         {
             Val[Son[x][]]+=Add[x];
             Add[Son[x][]]+=Add[x];
             Max[Son[x][]]+=Add[x];
         }
         Add[x]=;
     }
 }

 void Push(int x)
 {
     if (Father[x]) Push(Father[x]);
     Pushdown(x);
 }

 void Splay(int x,int tar)
 {
     Push(x);
     for (int fa; (fa=Father[x])!=tar; Rotate(x))
         if (Father[fa]!=tar)
             Rotate(Get(fa)==Get(x)?fa:x);
     if (!tar) Root=x;
 }

 int Findkth(int x)
 {
     int now=Root;
     while ()
     {
         Pushdown(now);
         if (Size[Son[now][]]>=x) now=Son[now][];
         else
         {
             x-=Size[Son[now][]];
             if (x==) {Splay(now,); return Val[now];}
             x--; now=Son[now][];
         }
     }
 }

 int Find(int x)
 {
     int now=Root,ans=;
     while ()
     {
         Pushdown(now);
         if (Max[Son[now][]]>x) now=Son[now][];
         else
         {
             if (Val[now]>x) {Splay(now,); return now;}
             now=Son[now][];
         }
     }
 }

 int Pre(int x)
 {
     Splay(x,);
     x=Son[x][];
     while (Son[x][]) x=Son[x][];
     return x;
 }

 void Insert(int x)
 {
     int now=Root,fa=;
     while ()
     {
         Pushdown(now);
         if (!now)
         {
             Father[x]=fa;
             Son[fa][Val[fa]<Val[x]]=x;
             Max[x]=Val[x]; Size[x]=;
             Splay(x,); return;
         }
         fa=now, now=Son[now][Val[now]<Val[x]];
     }
 }

 void DFS(int x,int k)
 {
     if (!x) return;
     Pushdown(x);
     DFS(Son[x][],k); DFS(Son[x][],k);
     Father[x]=Son[x][]=Son[x][]=Size[x]=Max[x]=;
     Val[x]-=k; Insert(x);
 }

 void Update(int k)
 {
     int x=Pre(Find(k)),y=Find(*k);
     Splay(x,); Splay(y,x);
     int s=Son[y][]; Son[y][]=Father[Son[y][]]=;
     DFS(s,k);
     Splay(y,);
     x=Pre(Find(*k)),y=n+;
     Splay(x,); Splay(y,x);
     if (!Son[y][]) return;
     Add[Son[y][]]-=k; Val[Son[y][]]-=k; Max[Son[y][]]-=k;
 }

 int main()
 {
     scanf("%d%d",&n,&m);
     for (int i=; i<=n+; ++i)
         scanf("%d",&a[i]);
     a[]=-2e9; a[n+]=2e9; Max[]=-2e9;
     sort(a+,a+n+);
     Root=Build(,,n+);
     for (int i=; i<=m; ++i)
     {
         scanf("%d%d",&opt,&k);
         if (opt==) printf("%d\n",Findkth(k+));
         else Update(k);
     }
 }