poj2761

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

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

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

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

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

所以复杂度为O(nlogn)

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

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

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

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

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

procedure update(i:longint);
  begin
    count[i]:=count[son[i,1]]+count[son[i,2]]+1;
  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,1]
      else p:=son[p,2];
    until false;
  end;

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

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

procedure rotate(x,w:longint);   //基本的BST左右旋，和splay是一样的
  var y:longint;
  begin
    y:=fa[x];
    if fa[y]=0 then root:=x;
    if fa[y]<>0 then
    begin
      if son[fa[y],1]=y then son[fa[y],1]:=x
      else son[fa[y],2]:=x;
    end;
    fa[x]:=fa[y];
    son[y,3-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<>0 do
    begin
      if key[i]<key[j] then 
      begin
        if son[j,1]=i then rotate(i,2)
        else rotate(i,1);
      end
      else break;
      j:=fa[i];
    end;
    if j=0 then root:=i;
  end;

procedure sift(i:longint);   //类似堆的下沉操作
  var j1,j2:longint;
  begin
    repeat
      j1:=son[i,1];       //选择较小的那个孩子旋转，使下沉后还能满足小根堆的性质
      j2:=son[i,2];
      if (j1=0) and (j2=0) then break;
      if (j1=0) then
        rotate(j2,1)
      else if (j2=0) then
        rotate(j1,2)
      else begin
        if key[j1]>key[j2] then rotate(j2,1) else rotate(j1,2);
      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 1].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-1;
      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=0 then
    begin
      root:=t;
      fa[t]:=0;
    end
    else begin
      p:=root;    //先插入到treap中
      repeat
        inc(count[p]);
        if b[p]>x then
        begin
          if son[p,1]=0 then break;
          p:=son[p,1];
        end
        else begin
          if son[p,2]=0 then break;
          p:=son[p,2];
        end;
      until false;
      fa[t]:=p;
      if b[p]>x then son[p,1]:=t else son[p,2]:=t;
      up(t);       //调整treap
    end;
  end;

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

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