poj2761

表面上看是主席树之类的区间k大

实际上，除了主席树，还可以测各种结构

因为题目中说，任意区间不会完全包含

于是，我们把区间按左端点排序，依次添加，用平衡树求当前的k大

每个狗最多被添加一次，删除一次

所以复杂度为O(nlogn)

被来写的是splay，结果一直WA到死

结果改成treap，第一次写就1Y了，不错

不过调treap需要把一组数据跑很多遍（至少我是这么认为的）

以免出现rp过好导致错误的程序跑对……

 const rd=;
 type node=record
        x,y,num,k:longint;
      end;
 var ans,pretty,fa,count,key,b:array[..] of longint;
     son:array[..,..] of longint;
     a:array[..] of node;
     p,j,root,n,q,i,t,s:longint;

 procedure update(i:longint);
   begin
     count[i]:=count[son[i,]]+count[son[i,]]+;
   end;

 function find(x:longint):longint;
   var p:longint;
   begin
     p:=root;
     repeat
       if b[p]=x then exit(p);
       if b[p]>x then p:=son[p,]
       else p:=son[p,];
     until false;
   end;

 function kth(x:longint):longint;    //找k大
   var p:longint;
   begin
     p:=root;
     while true do
     begin
       if count[son[p,]]+=x then exit(p);
       if count[son[p,]]+>x then p:=son[p,]
       else begin
         x:=x-count[son[p,]]-;
         p:=son[p,];
       end;
     end;
   end;

 procedure clear(i:longint);
   begin
     count[i]:=;
     son[i,]:=;
     son[i,]:=;
     fa[]:=;
     count[]:=;
   end;

 procedure rotate(x,w:longint);   //基本的BST左右旋，和splay是一样的
   var y:longint;
   begin
     y:=fa[x];
     if fa[y]= then root:=x;
     if fa[y]<> then
     begin
       if son[fa[y],]=y then son[fa[y],]:=x
       else son[fa[y],]:=x;
     end;
     fa[x]:=fa[y];
     son[y,-w]:=son[x,w];
     fa[son[x,w]]:=y;
     son[x,w]:=y;
     fa[y]:=x;
     update(y);
     update(x);
   end;

 procedure swap(var a,b:node);
   var c:node;
   begin
     c:=a;
     a:=b;
     b:=c;
   end;

 procedure up(i:longint);     //类似堆的上浮操作
   var j:longint;
   begin
     j:=fa[i];
     while j<> do
     begin
       if key[i]<key[j] then 
       begin
         if son[j,]=i then rotate(i,)
         else rotate(i,);
       end
       else break;
       j:=fa[i];
     end;
     if j= then root:=i;
   end;

 procedure sift(i:longint);   //类似堆的下沉操作
   var j1,j2:longint;
   begin
     repeat
       j1:=son[i,];       //选择较小的那个孩子旋转，使下沉后还能满足小根堆的性质
       j2:=son[i,];
       if (j1=) and (j2=) then break;
       if (j1=) then
         rotate(j2,)
       else if (j2=) then
         rotate(j1,)
       else begin
         if key[j1]>key[j2] then rotate(j2,) else rotate(j1,);
       end;
     until false;
   end;

 procedure sort(l,r: longint);
   var i,j,x,y: longint;
   begin
     i:=l;
     j:=r;
     x:=a[(l+r) shr ].x;
     repeat
       while (a[i].x<x) do inc(i);
       while (x<a[j].x) do dec(j);
       if not(i>j) then
       begin
         swap(a[i],a[j]);
         inc(i);
         j:=j-;
       end;
     until i>j;
     if l<j then sort(l,j);
     if i<r then sort(i,r);
   end;

 procedure insert(x:longint);
   var p:longint;
   begin
     inc(t);
     inc(s);
     clear(t);
     key[t]:=trunc(random(rd));    //随机生成一个优先级，这个优先级满足小根堆的性质
     b[t]:=x;
     if root= then
     begin
       root:=t;
       fa[t]:=;
     end
     else begin
       p:=root;    //先插入到treap中
       repeat
         inc(count[p]);
         if b[p]>x then
         begin
           if son[p,]= then break;
           p:=son[p,];
         end
         else begin
           if son[p,]= then break;
           p:=son[p,];
         end;
       until false;
       fa[t]:=p;
       if b[p]>x then son[p,]:=t else son[p,]:=t;
       up(t);       //调整treap
     end;
   end;

 procedure delete(x:longint);
   var i,p:longint;
   begin
     i:=find(x);
     key[i]:=;   //只是为了清楚，treap删除是把当前节点旋转到叶节点
     dec(s);
     sift(i);
     p:=i;
     while p<>root do    //注意删除时要更改它的父亲（祖先）的子树规模
     begin
       dec(count[fa[p]]);
       p:=fa[p];
     end;
     if son[fa[i],]=i then son[fa[i],]:=
     else son[fa[i],]:=;
     count[i]:=;
     key[i]:=;
     b[i]:=;
     fa[i]:=;
     if s= then root:=;
   end;

 begin
   randomize;
   readln(n,q);
   for i:= to n do
     read(pretty[i]);
   readln;
   for i:= to q do
   begin
     readln(a[i].x,a[i].y,a[i].k);
     a[i].num:=i;
   end;
   count[]:=;
   sort(,q);
   root:=;
   t:=;
   for i:=a[].x to a[].y do
     insert(pretty[i]);
   ans[a[].num]:=b[kth(a[].k)];
   for i:= to q do   //按顺序一次添加删除
   begin
     if a[i].x>a[i-].y then
     begin
       root:=;
       t:=;
       s:=;
       fillchar(fa,sizeof(fa),);
       fillchar(son,sizeof(son),);
       fillchar(count,sizeof(count),);
       fillchar(b,sizeof(b),);
       fillchar(key,sizeof(key),);
       for j:=a[i].x to a[i].y do
       begin
         insert(pretty[j]);
       end;
     end
     else begin
       for j:=a[i-].y+ to a[i].y do
         insert(pretty[j]);
       for j:=a[i-].x to a[i].x- do
       begin
         delete(pretty[j]);
       end;
     end;
     p:=kth(a[i].k);
     ans[a[i].num]:=b[p];
   end;
   for i:= to q do
     writeln(ans[i]);
 end.