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[..,..] of longint;
     f:array[..,..,..] of longint;
     x,y:array[..] of longint;
     d:array[..] of longint;
     sum:array[..] 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),);
     for i:= to n do
     begin
       y[i]:=ord(s[i]);
       inc(sum[y[i]]);
     end;
     for i:= to  do
       inc(sum[i],sum[i-]);
     for i:=n downto  do
     begin
       sa[k,sum[y[i]]]:=i;
       dec(sum[y[i]]);
     end;
     p:=;
     rank[k,sa[k,]]:=;
     for i:= to n do
     begin
       if (y[sa[k,i]]<>y[sa[k,i-]]) then inc(p);
       rank[k,sa[k,i]]:=p;
     end;
     m:=p;
     j:=;
     while m<n do
     begin
       y:=rank[k];
       fillchar(sum,sizeof(sum),);
       p:=;
       for i:=n-j+ to n do
       begin
         inc(p);
         x[p]:=i;
       end;
       for i:= to n do
         if sa[k,i]>j then
         begin
           inc(p);
           x[p]:=sa[k,i]-j;
         end;

       for i:= to n do
       begin
         rank[k,i]:=y[x[i]];
         inc(sum[rank[k,i]]);
       end;
       for i:= to m do
         inc(sum[i],sum[i-]);
       for i:=n downto  do
       begin
         sa[k,sum[rank[k,i]]]:=x[i];
         dec(sum[rank[k,i]]);
       end;
       p:=;
       rank[k,sa[k,]]:=;
       for i:= to n do
       begin
         if (y[sa[k,i]]<>y[sa[k,i-]]) or (y[sa[k,i]+j]<>y[sa[k,i-]+j]) then inc(p);
         rank[k,sa[k,i]]:=p;
       end;
       m:=p;
       j:=j shl ;
     end;
     h[k,]:=;
     p:=;
     for i:= to n do
     begin
       if rank[k,i]= then continue;
       j:=sa[k,rank[k,i]-];
       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> then dec(p);
     end;
   end;

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

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

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

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

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