bzoj2119

题意就是差分后求形如ABA的串的个数，B的长度为M

这是2011国家集训队互测的试题，是道好题，我直接给出出题人的题解吧：

对于这种在线性序列上的组合计数问题，我们很容易想到一个工具：分治！分治算法在形如快速排序等地方能顺利优化算法，我们尝试将其运用至本题中。

不妨设过程F(Left,Right)可以统计在区间[Left,Right]中满足条件的子序列的个数。

设Mid为区间[Left,Right]的中点由于分治执行，我们不需要统计那些属于[Left,Mid],[Mid+1,Right]中的子序列，剩下的我们分两种情况讨论。

1、 点Mid∈Q。这种情况由于|Q|非常小，我们可以直接枚举Q的位置，然后我们可以穷举A部分长度，然后后缀数组+RMQ解决这个问题

    此时算法多了一个系数M，不过整体仍然可以在O(NMLogN)的复杂度内完成。

2、 点Mid∉Q，这种情况就比较麻烦了，可以表示成如下示意图：

由于Mid的存在，P2被分割成了3份，由于P1=P2，我们把P1也分割成3份，经过仔细观察，我们发现只需要枚举红线的位置即可解决此部分的统计问题。黄色部分的最大匹配值可以通过将整个Mid左面的部分倒置后求LCP可得。而Mid以及绿色部分的匹配值可以直接通过后缀数组+RMQ求的。知道了绿色与黄色部分的最大值后，那么Q的位置个数也可以相应得出，问题得到解决，此部分复杂度为O(NLogN)。

方法三总复杂度为O(NMLogN)，为一个非常优秀的算法。

 

const eps=1e-8;
var s,h,sa,rank:array[0..100010,0..1] of longint;
    sum,a,b,x,y:array[0..100010] of longint;
    f:array[0..100010,0..20,0..1] of longint;
    d:array[0..20] of longint;
    t,mx,ans,i,n,m:longint;

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

function min(a,b:longint):longint;
  begin
    if a>b then exit(b) else exit(a);
  end;

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

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

function ask(l,r,k:longint):longint;
  var p:longint;
  begin
    if l>r then swap(l,r);
    inc(l);
    p:=trunc(ln(r-l+1)/ln(2)+eps);
    exit(min(f[l,p,k],f[r-d[p]+1,p,k]));
  end;

procedure work(l,r:longint);
  var mid,i,j,x,y:longint;
  begin
    if r-l+1<m+2 then exit;
    mid:=(l+r) shr 1;
    for i:=mid-m+1 to mid do
      for j:=i-1 downto l do
      begin
        if r-(i+m)+1<i-j then break;
        if ask(rank[j,0],rank[i+m,0],0)>=i-j then inc(ans);
      end;

    for i:=l to mid-m-1 do
    begin
      x:=min(ask(rank[i,0],rank[mid,0],0),mid-i-m);
      if (x<1) then continue;
      y:=ask(rank[n+1-i,1],rank[n+1-mid,1],1);
      y:=min(y-1,min(i-l,mid-i-m-1));
      if y<mid-i-m-x then continue;
      ans:=ans+min(x,y-(mid-i-m-x)+1);
    end;
    for i:=mid+m+1 to r do
    begin
      y:=min(i-mid-m,ask(rank[n+1-i,1],rank[n+1-mid,1],1));
      if y<1 then continue;
      x:=ask(rank[i+1,0],rank[mid+1,0],0);
      x:=min(x,min(r-i,i-mid-m-1));
      if x<i-mid-m-y then continue;
      ans:=ans+min(y,x-(i-mid-m-y)+1);
    end;
    work(l,mid-1);
    work(mid+1,r);
  end;

procedure sort(l,r:longint);
  var i,j,x:longint;
  begin
    i:=l;
    j:=r;
    x:=a[(l+r) shr 1];
    repeat
      while a[i]<x do inc(i);
      while x<a[j] do dec(j);
      if not(i>j) then
      begin
        swap(a[i],a[j]);
        swap(b[i],b[j]);
        inc(i);
        dec(j);
      end;
    until i>j;
    if l<j then sort(l,j);
    if i<r then sort(i,r);
  end;

begin
  readln(n,m);
  for i:=1 to n do
    read(a[i]);
  dec(n);
  for i:=1 to n do
    s[i,0]:=a[i+1]-a[i];

  for i:=1 to n do
  begin
    a[i]:=s[i,0];
    b[i]:=i;
  end;
  sort(1,n);
  mx:=1;
  s[b[1],0]:=1;
  for i:=2 to n do
  begin
    if a[i]<>a[i-1] then inc(mx);
    s[b[i],0]:=mx;
  end;
  for i:=1 to n do
    s[i,1]:=s[n+1-i,0];
  t:=trunc(ln(n)/ln(2)+eps);
  d[0]:=1;
  for i:=1 to t do
    d[i]:=d[i-1]*2;
  suffix(0);
  suffix(1);
  work(1,n);
  writeln(ans);
end.