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

var f:array[0..210,0..maxn] of longint;
    a1,a2:array[0..1010,0..1010] of longint;
    be,h,s,a,b,c,rank:array[0..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 2];
    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-1;
      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]]:=-1;
  end;

procedure pre;
  var i,j,p,q:longint;
  begin
    for i:=1 to tot do   //预处理在1..i的块中数出现的次数
    begin
      p:=i*size;
      if p>n then p:=n;
      for j:=(i-1)*size+1 to p do
        inc(s[rank[j]]);
      for j:=1 to m do
        f[i,j]:=s[j];
    end;
    for i:=1 to tot do  //预处理i~j块的答案
    begin
      p:=0;
      q:=2147483647;
      fillchar(s,sizeof(s),0);
      for j:=(i-1)*size+1 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),255);
  end;

function ask(x,y:longint):longint;
  var i,p,q,w:longint;
  begin
    if be[x]=be[y] then
    begin
      p:=0;
      q:=2147483647;
      for i:=x to y do
      begin
        if s[rank[i]]=-1 then s[rank[i]]:=0;
        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]+1,be[y]-1];
      q:=a2[be[x]+1,be[y]-1];
      for i:=x to be[x]*size do
      begin
        if s[rank[i]]=-1 then s[rank[i]]:=f[be[y]-1,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]-1)*size+1 to y do
      begin
        if s[rank[i]]=-1 then s[rank[i]]:=f[be[y]-1,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]-1)*size+1,y);
      exit(q);
    end;
  end;

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