poj3580

区间操作的究极题，我们一个个来分析
其实只有insert,delete,revolve三种没讲过
insert 先把x旋到根，一开始我比较SB的，准备把新节点插入到右子树的最左节点，这显然很烦
好的方法是，直接在根和右孩子之间插入即可，相当于right[new]=right[root] right[root]=new
然后维护一下new和root即可即可
delete 我一开始使用的是杨思雨大神splay论文中的方法，但是好像很烦
后来发现，一个比较简洁的做法，先把x的后继旋到根，然后把x旋到根的儿子的位置上（显然是左孩子）
显然x是不含有右子树的，所以，直接删去x即可（就是x的左子树直接与根相连
revolve 这是这道题最难的一个操作了，感觉自己写的也不是很好，还是讲讲方法吧
首先这个操作的本质是[l,k][k+1,r]这两个区间交换位置
考虑到假如在k和k+1中间有一个中间点，那么我只要把中间点旋到区间的根上然后直接交换左右子树即可
但是是不存在的，所以我们考虑先把k作为这个中间点，交换完左右子树后再把k插入到区间最后
也就是先把k旋到区间根上，然后交换左右子树，然后把k节点删去，再把他插入区间末尾
如果l=k，就不需要删去插入这一步了，感觉写得挺麻烦的

const inf=2147483647;

var son:array[0..200010,1..2] of longint;
    count,fa,a,lazy,mina:array[0..200010] of longint;
    v:array[0..200010] of boolean;
    n,m,i,x,y,z,p,root:longint;
    s:string;
    ch:char;

function min(a,b:longint):longint;
  begin
    if a>b then exit(b) else exit(a);
  end;

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

procedure add(x,y:longint);
  begin
    mina[x]:=mina[x]+y;
    a[x]:=a[x]+y;
    lazy[x]:=lazy[x]+y;
  end;

procedure change(x:longint);
  begin
    swap(son[x,1],son[x,2]);
    v[x]:=not v[x];
  end;

procedure update(x:longint);
  begin
    count[x]:=count[son[x,1]]+count[son[x,2]]+1;
    mina[x]:=min(a[x],min(mina[son[x,1]],mina[son[x,2]]));
  end;

procedure push(x:longint);
  var l,r:longint;
  begin
    l:=son[x,1];
    r:=son[x,2];
    if lazy[x]<>0 then
    begin
      if l<>-1 then add(l,lazy[x]);
      if r<>-1 then add(r,lazy[x]);
      lazy[x]:=0;
    end;
    if v[x] then
    begin
      if l<>-1 then change(l);
      if r<>-1 then change(r);
      v[x]:=false;
    end;
  end;

procedure rotate(x,w:longint);
  var y:longint;
  begin
    push(x);
    y:=fa[x];
    if fa[y]<>-1 then
    begin
      if son[fa[y],1]=y then son[fa[y],1]:=x
      else son[fa[y],2]:=x;
    end
    else root:=x;
    fa[x]:=fa[y];
    son[y,3-w]:=son[x,w];
    if son[x,w]<>-1 then fa[son[x,w]]:=y;
    son[x,w]:=y;
    fa[y]:=x;
    update(y);
    update(x);
  end;

procedure splay(x,f:longint);
  var y:longint;
  begin
    while fa[x]<>f do
    begin
      y:=fa[x];
      if fa[y]=f then
      begin
        if son[y,1]=x then rotate(x,2)
        else rotate(x,1);
      end
      else begin
        if son[fa[y],1]=y then
        begin
          if son[y,1]=x then rotate(y,2) else rotate(x,1);
          rotate(x,2);
        end
        else begin
          if son[y,1]=x then rotate(x,2) else rotate(y,1);
          rotate(x,1);
        end;
      end;
    end;
  end;

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

procedure getrange;  //提取区间
  begin
    x:=find(x);
    y:=find(y+2);
    splay(x,-1);
    splay(y,x);
  end;

procedure insert(x,p:longint); // p是新插入节点
  begin
    splay(x,-1);
    son[p,2]:=son[x,2];
    fa[son[x,2]]:=p;
    son[x,2]:=p;
    fa[p]:=x;
    update(p);
    update(x);
  end;

procedure delete(x,p:longint); //p是x的后继节点
  begin
    splay(p,-1);
    splay(x,p);
    if son[x,1]<>-1 then fa[son[x,1]]:=p;
    son[p,1]:=son[x,1];
    son[x,1]:=-1;
    son[x,2]:=-1;
    fa[x]:=-1;
    update(p);
  end;

function build(l,r:longint):longint;
  var m:longint;
  begin
    m:=(l+r) shr 1;
    build:=m;
    if m-1>=l then
    begin
      son[m,1]:=build(l,m-1);
      fa[son[m,1]]:=m;
    end;
    if m+1<=r then
    begin
      son[m,2]:=build(m+1,r);
      fa[son[m,2]]:=m;
    end;
    update(m);
  end;

procedure revolve;
  var l,r,p,last:longint;
  begin
    last:=find(y-z+1); // 交换[x,y-z][y-z+1,y];
    if y-z=x then
    begin
      getrange;
      splay(last,y);
      swap(son[last,1],son[last,2]);
    end
    else begin
      l:=x;
      r:=y;
      getrange;
      splay(last,y);
      swap(son[last,1],son[last,2]);
      //交换完后，中间点对应区间上的点也不同了
      p:=find(l+z+2);  //注意这里两处找位置对应树上的点，交换删除后，同一位置对应树上的点会不不同
      delete(last,p);
      p:=find(r);
      insert(p,last);
    end;
  end;

begin
  readln(n);
  fillchar(son,sizeof(son),255);
  fillchar(fa,sizeof(fa),255);
  for i:=1 to n do
    readln(a[i]);
  for i:=-1 to n+1 do
    mina[i]:=inf;
  count[-1]:=0;
  a[-1]:=inf;
  a[0]:=inf;
  a[n+1]:=inf;
  root:=build(0,n+1);
  inc(n);
  readln(m);
  for i:=1 to m do
  begin
    read(ch);
    s:='';
    while ch<>' ' do
    begin
      s:=s+ch;
      read(ch);
    end;
    if s='ADD' then
    begin
      readln(x,y,z);
      getrange;
      add(son[y,1],z);
    end
    else if s='REVERSE' then
    begin
      readln(x,y);
      getrange;
      change(son[y,1]);
    end
    else if s='REVOLVE' then
    begin
      readln(x,y,z);
      z:=z mod (y-x+1);  //注意
      if z<>0 then revolve;
    end
    else if s='INSERT' then
    begin
      readln(x,y);
      x:=find(x+1);
      inc(n);  mina[n]:=y; a[n]:=y;  count[n]:=1;
      insert(x,n);
    end
    else if s='DELETE' then
    begin
      readln(x);
      p:=find(x+2);
      x:=find(x+1);
      delete(x,p);
    end
    else begin
      readln(x,y);
      getrange;
      writeln(mina[son[y,1]]);
    end;
  end;
end.