bzoj3230

以前觉得这题好难，现在觉得这题还是挺简单
首先看到类似LCP问题不难想到后缀数组吧
前后的相似需要我们分别做一个后缀数组和“前缀数组”（就是把字符串反向然后跑后缀数组）
这道题的难点就在于如何确定子串是什么
考虑到一个有用的结论：任何一个子串都是某一个后缀的某一个前缀
由于做完后缀数组之后，后缀已经按照从小到大排列了
因此考虑相邻名次后缀sa[i]和sa[i-1]，然后在这两个后缀间，还夹着一些子串
不难发现，这些子串就是后缀sa[i]从第h[i]+1位开始的前缀
为什么是从h[i]+1开始的前缀呢，因为前缀1~h[i]在一定已经在后缀sa[i-1]出现过了，要避免重复
因此，我们可以计算相邻两个后缀之间不同的子串数目，然后维护前缀和
这样就可以用二分来确定名词为x的子串是哪个后缀的前缀
然后求相似程度不难想到用ST解决 利用LCP(i,j)=min(height[rank[i]+1~rank[j]]) 假定rank[i]<rank[j]
注意这道题名次可能会爆longint，我一开始都想到子串数目会爆longint，可读入的时候竟然忘了用int64，囧……~

var sa,rank,h:array[1..2,0..120010] of longint;
    f:array[1..2,0..100010,0..20] of longint;
    x,y:array[0..120010] of longint;
    d:array[0..20] of longint;
    sum:array[0..100010] of int64;
    s1,s2:ansistring;
    i,n,t:longint;
    p,q:int64;

function min(a,b:int64):int64;
  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 suffix(s:ansistring;k:longint);
  var m,i,j:longint;
  begin
    fillchar(sum,sizeof(sum),0);
    for i:=1 to n do
    begin
      y[i]:=ord(s[i]);
      inc(sum[y[i]]);
    end;
    for i:=2 to 127 do
      inc(sum[i],sum[i-1]);
    for i:=n downto 1 do
    begin
      sa[k,sum[y[i]]]:=i;
      dec(sum[y[i]]);
    end;
    p:=1;
    rank[k,sa[k,1]]:=1;
    for i:=2 to n do
    begin
      if (y[sa[k,i]]<>y[sa[k,i-1]]) then inc(p);
      rank[k,sa[k,i]]:=p;
    end;
    m:=p;
    j:=1;
    while m<n do
    begin
      y:=rank[k];
      fillchar(sum,sizeof(sum),0);
      p:=0;
      for i:=n-j+1 to n do
      begin
        inc(p);
        x[p]:=i;
      end;
      for i:=1 to n do
        if sa[k,i]>j then
        begin
          inc(p);
          x[p]:=sa[k,i]-j;
        end;

      for i:=1 to n do
      begin
        rank[k,i]:=y[x[i]];
        inc(sum[rank[k,i]]);
      end;
      for i:=2 to m do
        inc(sum[i],sum[i-1]);
      for i:=n downto 1 do
      begin
        sa[k,sum[rank[k,i]]]:=x[i];
        dec(sum[rank[k,i]]);
      end;
      p:=1;
      rank[k,sa[k,1]]:=1;
      for i:=2 to n do
      begin
        if (y[sa[k,i]]<>y[sa[k,i-1]]) or (y[sa[k,i]+j]<>y[sa[k,i-1]+j]) then inc(p);
        rank[k,sa[k,i]]:=p;
      end;
      m:=p;
      j:=j shl 1;
    end;
    h[k,1]:=0;
    p:=0;
    for i:=1 to n do
    begin
      if rank[k,i]=1 then continue;
      j:=sa[k,rank[k,i]-1];
      while (i+p<=n) and (j+p<=n) and (s[i+p]=s[j+p]) do inc(p);
      h[k,rank[k,i]]:=p;
      if p>0 then dec(p);
    end;
  end;

procedure rmq(k:longint);
  var t,i,j:longint;
  begin
    for i:=1 to n do
      f[k,i,0]:=h[k,i];
    t:=trunc(ln(n)/ln(2));
    for j:=1 to t do
      for i:=1 to n do
        if (i+d[j]-1<=n) then
          f[k,i,j]:=min(f[k,i,j-1],f[k,i+d[j-1],j-1])
        else break;
  end;

function ask(x,y,k:longint):longint;
  var t:longint;
  begin
    if x=y then exit(n+1-sa[k,x]);
    if x>y then swap(x,y);
    inc(x);
    t:=trunc(ln(y-x+1)/ln(2));
    exit(min(f[k,x,t],f[k,y-d[t]+1,t]));
  end;

function find(x:int64):longint;
  var l,m,r:longint;
  begin
    l:=0;
    r:=n;
    while l<=r do
    begin
      m:=(l+r) shr 1;
      if (sum[m-1]<x) and (sum[m]>=x) then exit(m);
      if sum[m]<x then l:=m+1 else r:=m-1;
    end;
  end;

function getans(x,y:int64):int64;
  var a,b,aa,bb,c:longint;
  begin
    a:=find(x);  //查找是哪个后缀的前缀
    b:=find(y);
    aa:=sa[1,a]+h[1,a]+x-sum[a-1]-1;  //定位前缀数组中的位置
    bb:=sa[1,b]+h[1,b]+y-sum[b-1]-1;
    aa:=rank[2,n+1-aa];  
    bb:=rank[2,n+1-bb];
    c:=min(h[1,a]+x-sum[a-1],h[1,b]+y-sum[b-1]);  //注意这里我们是求子串所在后缀的LCP，可能会超出原来子串的长度
    getans:=sqr(min(c,ask(a,b,1)))+sqr(min(c,ask(aa,bb,2)));
  end;

begin
  readln(n,t);
  readln(s1);
  s2:='';
  for i:=n downto 1 do
    s2:=s2+s1[i];
  suffix(s1,1);
  suffix(s2,2);
  d[0]:=1;
  for i:=1 to trunc(ln(n)/ln(2)) do
    d[i]:=d[i-1]*2;
  rmq(1);  //处理ST
  rmq(2);
  sum[0]:=0;
  for i:=1 to n do
    sum[i]:=sum[i-1]+n+1-sa[1,i]-h[1,i];
  for i:=1 to t do
  begin
    readln(p,q);
    if (p>sum[n]) or (q>sum[n]) then  //判断是否超出子串数目
    begin
      writeln(-1);
      continue;
    end;
    writeln(getans(p,q));
  end;
end.