bzoj3744

这道题是目前我做bzoj最感动的一题没有之一……
首先先警示一下，分块的题目能不套主席树尽量不套
因为主席树不仅回答来一个log而且常数也比较大，对于分块这种根号的算法非常不适合
这里是求区间逆序对，考虑查询，不难想到答案是[l,r]所夹整块之间的逆序对数目和两边的数所带来的逆序对数目和
首先第一部分是可以预处理出来的，算法是O(n*tot*logn)
第二部分裸的想法是求每个数ai在区间[l,i]比它小的个数，然后可以用主席树搞搞
但是不幸的是，这样直接T到死，自测bzoj第一点的数据就跑了24s……伤不起
所以考虑bzoj2724的做法，我们还是先预处理f[i,j],g[i,j]表示1~i块内比j大的数和比j小的数的个数
考虑两边的数ai,令它构成一个序列bj,这些数所带来的逆序对数目就是
如果ai在整块左边,就是=[l,r]所夹整块内比它小的数个数，在整块右边就是=[l,r]所夹整块内比它大的数个数
最后再加上bj序列的逆序对数目就是答案
考虑一种快速计算逆序对的算法，不难想到用树状数组，这已经相当优
下面就是令人感动的事情了，用树状数组替代主席树之后，程序已经能跑到28s左右
想办法干掉fillchar并在调整一下块的大小，优化到了23,24s左右
然后始终没能跑进20s……然后我就各种想，突然发现
当l正好是一个块的左端点时，我的程序仍然遍历了l所在的块（很多分块的程序都是这样），其实可以没必要
加了这个优化本地正好跑了20s，激动了，然后试着把r正好是块的右端点也特判一下
王苍啊，终于过了，在bzoj上跑了18s……
出题人大概是故意卡常数的吧……
有幸成为这道题第一个pascal通过者，非常感动（苦逼的pascal伤不起啊）
附上丑陋的代码：

const maxn=50000;

var s:array[0..300,0..300] of longint;
    f,g:array[0..300,0..maxn] of longint;
    co,v,a,be,b,c,rank,h:array[0..maxn] of longint;
    time,i,size,n,m,j,k,ans,x,y,t,tot,p:longint;

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

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:longint);
  begin
    while x<=p do
    begin
      if v[x]<>time then
      begin
        c[x]:=0;
        v[x]:=time;
      end;
      inc(c[x]);
      x:=x+lowbit(x);
    end;
  end;

function ask(x:longint):longint;
  begin
    ask:=0;
    while x>0 do
    begin
      if v[x]<>time then  //为了不用fillchar加了一个时间戳
      begin
        c[x]:=0;
        v[x]:=time;
      end;
      ask:=ask+c[x];
      x:=x-lowbit(x);
    end;
  end;

procedure sort(l,r: longint);
  var i,j,x,y: longint;
  begin
    i:=l;
    j:=r;
    x:=b[(l+r) shr 1];
    repeat
      while b[i]<x do inc(i);
      while x<b[j] do dec(j);
      if not(i>j) then
      begin
        swap(b[i],b[j]);
        swap(h[i],h[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;

function getans(l,r:longint):longint;
  var i,j,x:longint;
  begin
    getans:=0;
    t:=0;
    if be[r]=be[l] then
    begin
      for i:=l to r do
      begin
        getans:=getans+t-ask(rank[i]);
        add(rank[i]);
        inc(t);
      end;
    end
    else begin
      x:=min(be[r]*size,n);
      if ((be[l]-1)*size+1=l) and (x=r) then exit(s[be[l],be[r]])  //正好是端点可以直接计算
      else if ((be[l]-1)*size+1=l) then
      begin
        getans:=getans+s[be[l],be[r]-1];
        for i:=(be[r]-1)*size+1 to r do
        begin
          x:=rank[i];
          getans:=getans+f[be[r]-1,x]-f[be[l]-1,x];
          getans:=getans+t-ask(x);
          add(x);
          inc(t);
        end;
        exit;
      end
      else if (x=r) then
      begin
        getans:=getans+s[be[l]+1,be[r]];
        for i:=l to be[l]*size do
        begin
          x:=rank[i];
          getans:=getans+g[be[r],x]-g[be[l],x];
          getans:=getans+t-ask(x);
          add(x);
          inc(t);
        end;
        exit;
      end;
      getans:=getans+s[be[l]+1,be[r]-1];
      for i:=l to be[l]*size do
      begin
        x:=rank[i];
        getans:=getans+g[be[r]-1,x]-g[be[l],x];
        getans:=getans+t-ask(x);  //为了只调用一次查询
        add(x);
        inc(t);
      end;
      for i:=(be[r]-1)*size+1 to r do
      begin
        x:=rank[i];
        getans:=getans+f[be[r]-1,x]-f[be[l],x];
        getans:=getans+t-ask(x);
        add(x);
        inc(t);
      end;
    end;
  end;

begin
  readln(n);
  size:=trunc(sqrt(n)/1.1);
  for i:=1 to n do
  begin
    read(a[i]);
    b[i]:=a[i];
    h[i]:=i;
    be[i]:=(i-1) div size+1;
  end;
  tot:=i div size;
  if i mod size<>0 then inc(tot);
  sort(1,n);
  p:=1;
  rank[h[1]]:=1;
  for i:=2 to n do
  begin
    if b[i]<>b[i-1] then inc(p);
    rank[h[i]]:=p;
  end;
  for i:=1 to tot do //预处理f[i,j],g[i,j]
  begin
    x:=min(i*size,n);
    for j:=(i-1)*size+1 to x do
      inc(co[rank[j]]);
    f[i,p]:=0;
    for j:=p-1 downto 1 do
      f[i,j]:=f[i,j+1]+co[j+1];
    g[i,1]:=0;
    for j:=2 to p do
      g[i,j]:=g[i,j-1]+co[j-1];
  end;
  for i:=1 to tot do  //预处理i~j块内的逆序对数
  begin
    t:=0;
    inc(time);
    for j:=(i-1)*size+1 to n do
    begin
      x:=t-ask(rank[j]);
      inc(s[i,be[j]],x);
      add(rank[j]);
      inc(t);
    end;
    for j:=i+1 to tot do
      s[i,j]:=s[i,j]+s[i,j-1];
  end;
  ans:=0;
  readln(m);
  for i:=1 to m do
  begin
    inc(time);
    readln(x,y);
    x:=x xor ans;
    y:=y xor ans;
    if x>y then swap(x,y);
    ans:=getans(x,y);
    writeln(ans);
  end;
end.