LINK：WD与数列
这道题可谓妙绝 我明白了一个增量统计的原理。
原本的想法是：差分之后 显然长度为1的单独统计 长度为2的以及更多就是字符串之间的匹配问题了。
对差分序列建立SAM 由于第一个是一定匹配的 且后面的大小关系相同 所以可以直接取差分后的来建立SAM.
考虑计算答案 容易想到对于某个节点单独统计答案 那就是right集合上len暴力扫了 可能可以通过45分 我没试过 且这个暴力过于暴力 也不好说明复杂度.
考虑一件事情 其实统计答案的本质是 len.right集合中x,y三者之间造成的贡献。
单独考虑两个x,y 此时没必要强制考虑当前节点的len 因为在之后 他们一定会把1~lenmx 都统计一遍 所以在两个right集第一次相遇时就可以把之后的答案给得到.
所以这个暴力的改进是 每次对于新加入的right集合直接 对已有的right集合计算贡献 且贡献的区间长度为1~len.
两个endpos之间产生贡献 最坏复杂度就是n^2的了.
这个就叫做增量统计贡献.
对于新加入的x统计之前所有的y的贡献 这个东西 可以利用线段树来快速统计 大体上就是判断lenmx的有多少 不是的话就利用|x-y|-1类似的东西统计。
这样就是logn快速统计一个决策的答案了。
不过这个决策的数量每次在合并的时候并没有保证 最坏还是n^2logn的。
考虑每次是两个决策集合合并的过程 利用启发式合并就可以保证每个决策最多被合并logn次了。
这样总复杂度nlog^2.非常的妙。
值得一提的是出题人的初衷是让我们写SA 利用容斥和 优秀的拆分那道题的方法 来统计答案 这样也很妙 这样可以做到nlogn.
不过这种 方法细节较多 没有线段树来的暴力 (理解优秀的拆分的方法就行辣
const int MAXN=300010<<1;
int n,last=1,id,cnt=1;ll ans,sum1,sum2;
int a[MAXN],f[MAXN],len[MAXN],c[MAXN],q[MAXN],w[MAXN],root[MAXN];
map<int,int>t[MAXN];vector<int>g[MAXN];
struct wy{int l,r;ll sum;int cnt;}s[MAXN*40];
inline void insert(int &p,int l,int r,int x)
{
if(!p)p=++id;
if(l==r){++c(p);sum(p)+=x;return;}
int mid=(l+r)>>1;
if(x<=mid)insert(l(p),l,mid,x);
else insert(r(p),mid+1,r,x);
sum(p)=sum(l(p))+sum(r(p));
c(p)=c(l(p))+c(r(p));
}
inline void insert(int x,int ww)
{
int p=last;
int np=last=++cnt;w[last]=last;
len[np]=len[p]+1;g[last].pb(ww);
insert(root[last],1,n-1,ww);
while(p&&!t[p][x])
{
t[p][x]=np;
p=f[p];
}
if(!p)f[np]=1;
else
{
int q=t[p][x];
if(len[q]==len[p]+1)f[np]=q;
else
{
int nq=++cnt;
t[nq]=t[q];f[nq]=f[q];
len[nq]=len[p]+1;
f[q]=f[np]=nq;
while(p&&t[p][x]==q)
{
t[p][x]=nq;
p=f[p];
}
}
}
}
inline void topsort()
{
rep(1,cnt,i)++c[len[i]];
rep(1,cnt,i)c[i]+=c[i-1];
rep(1,cnt,i)q[c[len[i]]--]=i;
}
inline int ask(int p,int l,int r,int L,int R)
{
if(!p||L>n-1||R<1||L>R)return 0;
if(L<=l&&R>=r)return c(p);
int mid=(l+r)>>1,cnt=0;
if(L<=mid)cnt+=ask(l(p),l,mid,L,R);
if(R>mid)cnt+=ask(r(p),mid+1,r,L,R);
return cnt;
}
inline void ask1(int p,int l,int r,int L,int R)
{
if(!p||L>n-1||R<1||L>R)return;
if(!p)return;
if(L<=l&&R>=r){sum1+=c(p);sum2+=sum(p);return;}
int mid=(l+r)>>1;
if(L<=mid)ask1(l(p),l,mid,L,R);
if(R>mid)ask1(r(p),mid+1,r,L,R);
}
inline int merge(int x,int y,int l,int r)
{
if(!x||!y)return x|y;
if(l==r){c(x)+=c(y);sum(x)+=sum(y);return x;}
int mid=(l+r)>>1;
l(x)=merge(l(x),l(y),l,mid);
r(x)=merge(r(x),r(y),mid+1,r);
sum(x)=sum(l(x))+sum(r(x));
c(x)=c(l(x))+c(r(x));
return x;
}
int main()
{
//freopen("1.in","r",stdin);
get(n);get(a[1]);
rep(2,n,i)get(a[i]),insert(a[i]-a[i-1],i-1);
topsort();
fep(cnt,2,i)
{
int x=q[i],fa=f[x];
if(fa==1)continue;
if(g[w[fa]].size()<g[w[x]].size())
{
swap(w[fa],w[x]);
swap(root[fa],root[x]);
}
//启发式合并保证复杂度正确.
for(ui int j=0;j<g[w[x]].size();++j)
{
int tn=g[w[x]][j];
ans+=(ll)ask(root[fa],1,n-1,tn+len[fa]+1,n-1)*len[fa];
ans+=(ll)ask(root[fa],1,n-1,1,tn-len[fa]-1)*len[fa];
sum1=sum2=0;ask1(root[fa],1,n-1,tn+1,tn+len[fa]);
ans+=sum2-sum1*tn-sum1;
sum1=sum2=0;ask1(root[fa],1,n-1,tn-len[fa],tn-1);
ans+=sum1*tn-sum2-sum1;
g[w[fa]].pb(tn);
}
root[fa]=merge(root[fa],root[x],1,n-1);
}
ans+=(ll)n*(n-1)/2;putl(ans);
return 0;
}