bzoj2724

分块大法好！
首先预处理第i块到第j块的答案，这是可以在O(n*tot)内处理出来的 tot表示块数
然后考虑询问对于[l,r]，答案只可能是[l,r]之间所夹整块[i,j]的答案和非整块中的位置上的数
下面我们要做的是快速求出一个数在区间[l,r]出现的次数
当然我一无脑就直接写了主席树，这当然可以复杂度为O(size*logn)
一开始TLE了，好来发现块大小为sqrt(n/log(n))最优，然后跑了20s就过了
后来一想，不对，直接预处理每个数在块1..i出现的次数不就可以了吗
这样求出一个数在区间[l,r]出现的次数只需要O(1)的时间，复杂度仅仅是O(size)
好像是的……这样可以在O(nsqrt(n))的时间内搞出来，这次只跑了7s左右
下面给出算法二

 const maxn=;

 var f:array[..,..maxn] of longint;
     a1,a2:array[..,..] of longint;
     be,h,s,a,b,c,rank:array[..maxn] of longint;
     ans,x,y,i,p,q,m,t,tot,size,n:longint;

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

 procedure sort(l,r: longint);
   var i,j,x,y: longint;
   begin
     i:=l;
     j:=r;
     x:=b[(l+r) div ];
     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(c[i],c[j]);
         inc(i);
         j:=j-;
       end;
     until i>j;
     if l<j then sort(l,j);
     if i<r then sort(i,r);
   end;

 procedure clear(l,r:longint);
   var i:longint;
   begin
     for i:=l to r do
       s[rank[i]]:=-;
   end;

 procedure pre;
   var i,j,p,q:longint;
   begin
     for i:= to tot do   //预处理在1..i的块中数出现的次数
     begin
       p:=i*size;
       if p>n then p:=n;
       for j:=(i-)*size+ to p do
         inc(s[rank[j]]);
       for j:= to m do
         f[i,j]:=s[j];
     end;
     for i:= to tot do  //预处理i~j块的答案
     begin
       p:=;
       q:=;
       fillchar(s,sizeof(s),);
       for j:=(i-)*size+ to n do
       begin
         inc(s[rank[j]]);
         if (s[rank[j]]>p) or ((s[rank[j]]=p) and (a[j]<q)) then
         begin
           p:=s[rank[j]];
           q:=a[j];
         end;
         a1[i,be[j]]:=p;
         a2[i,be[j]]:=q;
       end;
     end;
     fillchar(s,sizeof(s),);
   end;

 function ask(x,y:longint):longint;
   var i,p,q,w:longint;
   begin
     if be[x]=be[y] then
     begin
       p:=;
       q:=;
       for i:=x to y do
       begin
         if s[rank[i]]=- then s[rank[i]]:=;
         inc(s[rank[i]]);
         if (s[rank[i]]>p) or (s[rank[i]]=p) and (a[i]<q) then
         begin
           p:=s[rank[i]];
           q:=a[i];
         end;
       end;
       clear(x,y);
       exit(q);
     end
     else begin
       p:=a1[be[x]+,be[y]-];
       q:=a2[be[x]+,be[y]-];
       for i:=x to be[x]*size do
       begin
         if s[rank[i]]=- then s[rank[i]]:=f[be[y]-,rank[i]]-f[be[x],rank[i]];
         inc(s[rank[i]]);  //关键
         if (s[rank[i]]>p) or (s[rank[i]]=p) and (a[i]<q) then
         begin
           p:=s[rank[i]];
           q:=a[i];
         end;
       end;
       for i:=(be[y]-)*size+ to y do
       begin
         if s[rank[i]]=- then s[rank[i]]:=f[be[y]-,rank[i]]-f[be[x],rank[i]];
         inc(s[rank[i]]);
         if (s[rank[i]]>p) or (s[rank[i]]=p) and (a[i]<q) then
         begin
           p:=s[rank[i]];
           q:=a[i];
         end;
       end;
       clear(x,be[x]*size);  //一点常数优化，不用fillchar
       clear((be[y]-)*size+,y);
       exit(q);
     end;
   end;

 begin
   readln(n,q);
   size:=trunc(sqrt(n));
   for i:= to n do
   begin
     read(a[i]);
     be[i]:=(i-) div size+;
     b[i]:=a[i];
     c[i]:=i;
   end;
   tot:=n div size;
   if n mod size<> then inc(tot);
   sort(,n);
   m:=;
   rank[c[]]:=;
   for i:= to n do
   begin
     if b[i]<>b[i-] then inc(m);
     rank[c[i]]:=m;
   end;
   pre;
   t:=;
   ans:=;
   for i:= to q do
   begin
     readln(x,y);
     x:=(x+ans-) mod n+;
     y:=(y+ans-) mod n+;
     if x>y then swap(x,y);
     ans:=ask(x,y);
     writeln(ans);
   end;
 end.