bzoj 3217: ALOEXT

将此神题作为博客园的第一篇文章，至此，数据结构基本学完了（或者说数据结构轮流虐了我一次！）

人生第一道7K代码题！

没什么，就是treap套个trie，然后tle是因为一定要用指针当时p党谁会用那么丑的指针，所以作罢。然后光荣tle（用自己的数据和云神的对拍是没有错的），然后竟然是第一个尝试写此题的p党！

好吧。oi路也算是步入正轨（虽然一开始就必须走在翻盘的路上……noip就不想说了……），那么接下来就重新回归基础，把图论那些东西重新搞好♂搞深♂入♂……

然后来看看3217第一个死掉的p党的代码吧（语言歧视题！）

好多个第一！

const
  maxd=;
  maxn1=;
  maxn2=;
  number=;
  mm=;

var
  son:array[..maxn1,..]of longint;
  sum,pp:array[..maxn1]of longint;
  size,root,left,right,p1,p2,value,fi,se,key:array[..maxn2]of longint;
  tot,tot1,tot2,sum1,sum2,n,m,sroot,big1,big2:longint;

function new1:longint;
begin
  inc(tot);
  exit(tot);
end;

function new2:longint;
var
  i:longint;
begin
  if sum1> then begin
    i:=pp[sum1];
    dec(sum1);
    sum[i]:=;
    son[i][]:=;
    son[i][]:=;
    exit(i);
  end;
  inc(sum2);
  exit(sum2);
end;

procedure clear(x:longint);
begin
  if x= then exit;
  inc(sum1);
  pp[sum1]:=x;
  clear(son[x][]);
  clear(son[x][]);
end;

function max(x,y:longint):longint;
begin
  if x<y then exit(y);
  exit(x);
end;

procedure swap(var x,y:longint);
var
  i:longint;
begin
  i:=x;
  x:=y;
  y:=i;
end;

function ask(x,y:longint):longint;
var
  ans,i,j:longint;
begin
  ans:=;
  for i:=maxd downto  do begin
    if x= then break;
    j:=y>>i and ;
    if sum[son[x][j xor ]]> then begin
      inc(ans,<<i);
      j:=j xor ;
    end;
    x:=son[x][j];
  end;
  exit(ans);
end;

procedure add(var x:longint;y:longint);
var
  i,j,t:longint;
begin
  if x= then x:=new2;
  t:=x;
  for i:=maxd downto - do begin
    inc(sum[t]);
    if i=- then exit;
    j:=y>>i and ;
    if son[t][j]= then son[t][j]:=new2;
    t:=son[t][j];
  end;
end;

procedure del(var x:longint;h,y:longint);
begin
  dec(sum[x]);
  if sum[x]= then begin
    clear(x);
    x:=;
    exit;
  end;
  if h=- then exit;
  del(son[x][y>>h and ],h-,y);
end;

procedure calc(var x,y:longint;z:longint);
begin
  if z>y then begin
    if z>x then begin
      y:=x;
      x:=z;
    end
    else y:=z;
  end;
end;

procedure merge(var x:longint;ll,rr:longint);
begin
  x:=new2;
  sum[x]:=sum[ll]+sum[rr];
  if sum[son[ll][]]+sum[son[rr][]]> then merge(son[x][],son[ll][],son[rr][]);
  if sum[son[ll][]]+sum[son[rr][]]> then merge(son[x][],son[ll][],son[rr][]);
end;

procedure up(x:longint);
begin
  if x= then exit;
  fi[x]:=fi[left[x]];
  se[x]:=se[left[x]];
  calc(fi[x],se[x],value[x]);
  calc(fi[x],se[x],fi[right[x]]);
  calc(fi[x],se[x],se[right[x]]);
  size[x]:=size[left[x]]+size[right[x]]+;
end;

procedure update(x:longint);
begin
  merge(root[x],root[left[x]],root[right[x]]);
  add(root[x],value[x]);
  up(x);
end;

procedure lt(var x:longint);
var
  k:longint;
begin
  k:=right[x];
  right[x]:=left[k];
  left[k]:=x;
  size[k]:=size[x];
  fi[k]:=fi[x];
  se[k]:=se[x];
  clear(root[k]);
  root[k]:=root[x];
  update(x);
  x:=k;
end;

procedure rt(var x:longint);
var
  k:longint;
begin
  k:=left[x];
  left[x]:=right[k];
  right[k]:=x;
  size[k]:=size[x];
  fi[k]:=fi[x];
  se[k]:=se[x];
  clear(root[k]);
  root[k]:=root[x];
  update(x);
  x:=k;
end;

procedure insert(var x:longint;y,z:longint);
begin
  if x= then begin
    x:=new1;
    value[x]:=z;
    key[x]:=random(number);
    left[x]:=;
    right[x]:=;
    add(root[x],z);
    fi[x]:=z;
    se[x]:=;
    size[x]:=;
    exit;
  end;
  if y<=size[left[x]]+ then begin
    insert(left[x],y,z);
    if key[left[x]]>key[x] then rt(x);
  end
  else begin
    insert(right[x],y-size[left[x]]-,z);
    if key[right[x]]>key[x] then lt(x);
  end;
  add(root[x],z);
  inc(size[x]);
  calc(fi[x],se[x],z);
end;

function change(x,y,new:longint):longint;
var
  old:longint;
begin
  if y=size[left[x]]+ then begin
    old:=value[x];
    del(root[x],maxd,old);
    add(root[x],new);
    value[x]:=new;
    up(x);
    exit(old);
  end;
  if y<=size[left[x]] then old:=change(left[x],y,new)
    else old:=change(right[x],y-size[left[x]]-,new);
  del(root[x],maxd,old);
  add(root[x],new);
  up(x);
  exit(old);
end;

function find(x,y:longint):longint;
begin
  if y=size[left[x]]+ then exit(value[x]);
  if y<=size[left[x]] then exit(find(left[x],y))
    else exit(find(right[x],y-size[left[x]]-));
end;

function delete(var x:longint;y:longint):longint;
var
  old:longint;
begin
  if y=size[left[x]]+ then begin
    old:=value[x];
    if left[x]= then x:=right[x]
    else
    if right[x]= then x:=left[x]
    else begin
      if key[left[x]]>key[right[x]] then begin
        rt(x);
        delete(right[x],y-size[left[x]]-);
      end
      else begin
        lt(x);
        delete(left[x],y);
      end;
      del(root[x],maxd,old);
    end;
    up(x);
    exit(old);
  end;
  if y<=size[left[x]] then old:=delete(left[x],y)
    else old:=delete(right[x],y-size[left[x]]-);
  del(root[x],maxd,old);
  up(x);
  exit(old);
end;

procedure before(x,l,r:longint);
var
  lsum:longint;
begin
  if x= then exit;
  lsum:=size[left[x]]+;
  if r<lsum then before(left[x],l,r)
    else
      if l>lsum then before(right[x],l-lsum,r-lsum)
        else
          if (l=) and (r=size[x]) then begin
            inc(tot1);
            p1[tot1]:=x;
            calc(big1,big2,fi[x]);
            calc(big1,big2,se[x]);
          end
          else begin
            inc(tot2);
            p2[tot2]:=value[x];
            calc(big1,big2,value[x]);
            if l<lsum then before(left[x],l,lsum-);
            if r>lsum then before(right[x],,r-lsum);
          end;
end;

function query(l,r:longint):longint;
var
  ll,rr,mid,ans,i:longint;
begin
  tot1:=;
  tot2:=;
  big1:=;
  big2:=;
  before(sroot,l,r);
  ans:=;
  //writeln(big2);
  if big2= then exit();
  for i:= to tot1 do p1[i]:=root[p1[i]];
  for i:= to tot1 do ans:=max(ans,ask(p1[i],big2));
  for i:= to tot2 do ans:=max(ans,p2[i] xor big2);
  exit(ans);
end;

procedure into;
var
  i,j:longint;
begin
  //randomize;
  readln(n,m);
  tot:=;
  sroot:=;
  for i:= to n do begin
    read(j);
    insert(sroot,i,j);
  end;
end;

procedure work;
var
  last,x,y:longint;
  ch:char;
begin
  last:=;
  readln;
  while m> do begin
    dec(m);
    read(ch);
    case ch of
      'I':begin
            readln(x,y);
            //x:=x mod n+;
            x:=(x+last mod n) mod n+;
            y:=(y+last mod mm) mod mm;
            //writeln(x,' ',y);
            insert(sroot,x,y);
            inc(n);
      end;
      'C':begin
            readln(x,y);
            //x:=x mod n+;
            x:=(x+last mod n) mod n+;
            y:=(y+last mod mm) mod mm;
            //writeln(x,' ',y);
            change(sroot,x,y);
      end;
      'D':begin
            readln(x);
            //x:=x mod n+;
            x:=(x+last mod n) mod n+;
            //writeln(x);
            delete(sroot,x);
            dec(n);
      end;
      'F':begin
            readln(x,y);
            //x:=x mod n+;
            //y:=y mod n+;
            x:=(x+last mod n) mod n+;
            y:=(y+last mod n) mod n+;
            if x>y then swap(x,y);
            //writeln(x,' ',y);
            last:=query(x,y);
            writeln(last);
      end;
    end;
  end;
end;

begin
  into;
  work;
end.

14.12.13……竟然没发现云神比较神奇的build操作（之前还以为慢了呢！）

procedure build(var x:longint;ll,rr:longint);
var
  mid,i:longint;
begin
  mid:=(ll+rr)>>;
  x:=mid;
  value[x]:=num[mid];
  key[x]:=random(number);
  left[x]:=;
  right[x]:=;
  if ll<mid then begin
    build(left[x],ll,mid-);
    if key[left[x]]>key[x] then swap(key[left[x]],key[x]);
  end;
  if rr>mid then begin
    build(right[x],mid+,rr);
    if key[right[x]]>key[x] then swap(key[right[x]],key[x]);
  end;
  update(x)
end;

结果还是tle……（搞到数据了……云14s蒟蒻18s……）