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=;

 var s:array[..,..] of longint;
     f,g:array[..,..maxn] of longint;
     co,v,a,be,b,c,rank,h:array[..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]:=;
         v[x]:=time;
       end;
       inc(c[x]);
       x:=x+lowbit(x);
     end;
   end;

 function ask(x:longint):longint;
   begin
     ask:=;
     while x> do
     begin
       if v[x]<>time then  //为了不用fillchar加了一个时间戳
       begin
         c[x]:=;
         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 ];
     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-;
       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:=;
     t:=;
     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]-)*size+=l) and (x=r) then exit(s[be[l],be[r]])  //正好是端点可以直接计算
       else if ((be[l]-)*size+=l) then
       begin
         getans:=getans+s[be[l],be[r]-];
         for i:=(be[r]-)*size+ to r do
         begin
           x:=rank[i];
           getans:=getans+f[be[r]-,x]-f[be[l]-,x];
           getans:=getans+t-ask(x);
           add(x);
           inc(t);
         end;
         exit;
       end
       else if (x=r) then
       begin
         getans:=getans+s[be[l]+,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]+,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;
       for i:=(be[r]-)*size+ to r do
       begin
         x:=rank[i];
         getans:=getans+f[be[r]-,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:= to n do
   begin
     read(a[i]);
     b[i]:=a[i];
     h[i]:=i;
     be[i]:=(i-) div size+;
   end;
   tot:=i div size;
   if i mod size<> then inc(tot);
   sort(,n);
   p:=;
   rank[h[]]:=;
   for i:= to n do
   begin
     if b[i]<>b[i-] then inc(p);
     rank[h[i]]:=p;
   end;
   for i:= to tot do //预处理f[i,j],g[i,j]
   begin
     x:=min(i*size,n);
     for j:=(i-)*size+ to x do
       inc(co[rank[j]]);
     f[i,p]:=;
     for j:=p- downto  do
       f[i,j]:=f[i,j+]+co[j+];
     g[i,]:=;
     for j:= to p do
       g[i,j]:=g[i,j-]+co[j-];
   end;
   for i:= to tot do  //预处理i~j块内的逆序对数
   begin
     t:=;
     inc(time);
     for j:=(i-)*size+ to n do
     begin
       x:=t-ask(rank[j]);
       inc(s[i,be[j]],x);
       add(rank[j]);
       inc(t);
     end;
     for j:=i+ to tot do
       s[i,j]:=s[i,j]+s[i,j-];
   end;
   ans:=;
   readln(m);
   for i:= 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.