bzoj1901

带修改的主席树
怎么搞呢，由于主席树满足减法性质，且维护的是前缀信息，所以我们不难想到套一个树状数组来优化
也很好理解，对于第i个位置，修改对后面的lowbit+都修改，求和lowbit-都求和
由于修改要修改logn个树，每棵树都要开辟logS个节点，所以空间复杂度是两个log值得注意
有修改还要将修改成的数一并离散化，所以带修改的主席树是一个离线数据结构

type node=record
       wh:char;
       l,r,x:longint;
     end;
     point=record
       l,r,s:longint;
     end;

var q:array[0..10010] of node;
    tree:array[0..3000010] of point;
    h,c,a,w,sa,d1,d2:array[0..20010] of longint;
    j,s,p,last,t,t1,t2,x,i,n,m:longint;

function lowbit(x:longint):longint;
  begin
    exit(x and (-x));
  end;

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

function find(x:longint):longint;
  var l,r,m:longint;
  begin
    l:=1;
    r:=p;
    while l<=r do
    begin
      m:=(l+r) shr 1;
      if sa[m]=x then exit(m);
      if sa[m]>x then r:=m-1 else l:=m+1;
    end;
  end;

procedure sort(l,r: longint);
  var i,j,x,y: longint;
  begin
    i:=l;
    j:=r;
    x:=a[(l+r) div 2];
    repeat
      while a[i]<x do inc(i);
      while x<a[j] 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 update(i:longint);
  begin
    tree[i].s:=tree[tree[i].l].s+tree[tree[i].r].s;
  end;

function build(l,r:longint):longint;
  var m,q:longint;
  begin
    inc(t);
    if l=r then exit(t)
    else begin
      q:=t;
      m:=(l+r) shr 1;
      tree[q].l:=build(l,m);
      tree[q].r:=build(m+1,r);
      exit(q);
    end;
  end;

function add(l,r,y,z:longint):longint;
  var m,q:longint;
  begin
    inc(t);
    if l=r then
    begin
      tree[t].s:=tree[last].s+z;
      exit(t);
    end
    else begin
      q:=t;
      m:=(l+r) shr 1;
      if y<=m then
      begin
        tree[q].r:=tree[last].r;
        last:=tree[last].l;
        tree[q].l:=add(l,m,y,z);
      end
      else begin
        tree[q].l:=tree[last].l;
        last:=tree[last].r;
        tree[q].r:=add(m+1,r,y,z);
      end;
      update(q);
      exit(q);
    end;
  end;

procedure insert(x,y,z:longint);
  begin
    while x<=n do
    begin
      last:=h[x];
      h[x]:=add(1,p,y,z);
      x:=x+lowbit(x);
    end;
  end;

function getans(l,r,x:longint):longint;
  var m,i,s1,s2,j:longint;
  begin
    if l=r then exit(sa[l])
    else begin
      m:=(l+r) shr 1;
      s1:=0;
      s2:=0;
      for i:=1 to t1 do
      begin
        j:=tree[d1[i]].l;
        s1:=s1+tree[j].s;
      end;
      for i:=1 to t2 do
      begin
        j:=tree[d2[i]].l;
        s2:=s2+tree[j].s;
      end;
      if s2-s1>=x then
      begin
        for i:=1 to t1 do
          d1[i]:=tree[d1[i]].l;
        for i:=1 to t2 do
          d2[i]:=tree[d2[i]].l;
        exit(getans(l,m,x));
      end
      else begin
        for i:=1 to t1 do
          d1[i]:=tree[d1[i]].r;
        for i:=1 to t2 do
          d2[i]:=tree[d2[i]].r;
        x:=x-(s2-s1);
        exit(getans(m+1,r,x));
      end;
    end;
  end;

function ask(l,r,x:longint):longint;
  var y:longint;
  begin
    t1:=0;
    t2:=0;
    y:=l-1;
    while y>0 do   //提取区间
    begin
      inc(t1);
      d1[t1]:=h[y];
      y:=y-lowbit(y);
    end;
    y:=r;
    while y>0 do
    begin
      inc(t2);
      d2[t2]:=h[y];
      y:=y-lowbit(y);
    end;
    exit(getans(1,p,x));
  end;

begin
  readln(n,m);
  s:=n;
  for i:=1 to n do
  begin
    read(c[i]);
    a[i]:=c[i];
  end;
  readln;
  for i:=1 to m do
  begin
    read(q[i].wh);
    if q[i].wh='Q' then
      readln(q[i].l,q[i].r,q[i].x)
    else begin
      readln(q[i].l,q[i].x);
      inc(s);
      a[s]:=q[i].x;
    end;
  end;
  sort(1,s);
  p:=1;
  sa[1]:=a[1];
  for i:=2 to s do  //离散化
    if a[i]<>a[i-1] then
    begin
      inc(p);
      sa[p]:=a[i];
    end;

  h[0]:=build(1,p);
  for i:=1 to n do
  begin
    w[i]:=find(c[i]);
    insert(i,w[i],1);
  end;
  for i:=1 to m do
  begin
    if q[i].wh='Q' then
      writeln(ask(q[i].l,q[i].r,q[i].x))
    else begin
      x:=find(q[i].x);
      insert(q[i].l,w[q[i].l],-1);  //修改的两步
      insert(q[i].l,x,1);
      w[q[i].l]:=x;
    end;
  end;
end.