BZOJ2119: 股市的预测（后缀数组）

Description

墨墨的妈妈热爱炒股，她要求墨墨为她编写一个软件，预测某只股票未来的走势。股票折线图是研究股票的必备工

具，它通过一张时间与股票的价位的函数图像清晰地展示了股票的走势情况。经过长时间的观测，墨墨发现很多股

票都有如下的规律：之前的走势很可能在短时间内重现！如图可以看到这只股票A部分的股价和C部分的股价的走势

如出一辙。通过这个观测，墨墨认为他可能找到了一个预测股票未来走势的方法。进一步的研究可是难住了墨墨，

他本想试图统计B部分的长度与发生这种情况的概率关系，不过由于数据量过于庞大，依赖人脑的力量难以完成，

于是墨墨找到了善于编程的你，请你帮他找一找给定重现的间隔（B部分的长度），有多少个时间段满足首尾部分

的走势完全相同呢？当然，首尾部分的长度不能为零。

Input

第一行包含两个整数N、M，分别表示需要统计的总时间以及重现的间隔（B部分的长度）。

接下来N行，每行一个整数，代表每一个时间点的股价。

4≤N≤50000 1≤M≤10 M≤N 所有出现的整数均不超过32位含符号整数。

Output

输出一个整数，表示满足条件的时间段的个数

Sample Input

12 4
1 2 3 4 8 9 1 2 3 4 8 9

Sample Output

解题思路：

还是很佩服后缀数组的思维。

这是求一个具有ABA结构的字符串个数。

发现一个性质，如果左右A足够长，

就可以将中间部分左右移动得到新答案。

枚举A的长度L，按L分块，边缘设为关键点。

易知关键点只能被一个串覆盖一次。

只需正反构建后缀数组求Lcp即可。

时间复杂度n(lnn+logn)

代码：

 #include<map>

 #include<cstdio>

 #include<cstring>

 #include<algorithm>

 const int N=;

 struct Sa{

     int sa[N];

     int tmr[N];

     int rnk[N];

     int has[N];

     int str[N];

     int hgt[N];

     int Rmq[][N];

     int lg[N];

     int cnt;

     int n;

     bool Same(int a,int b,int l)

     {

         if(a+l>n||b+l>n)

             return false;

         return (rnk[a]==rnk[b])&&(rnk[a+l]==rnk[b+l]);

     }

     void Insert(int *a,int len)

     {

         for(int i=;i<=len;i++)

             str[i]=a[i];

         n=len;

         return ;

     }

     void Reverse(int *a,int len)

     {

         int j=;

         for(int i=len;i;i--)

             str[++j]=a[i];

         n=len;

         return ;

     }

     void Build(void)

     {

         for(int i=;i<=n;i++)

             lg[i]=lg[i/]+;

         for(int i=;i<=n;i++)

             has[str[i]]++;

         for(int i=;i<=n;i++)

             if(has[i])

                 tmr[i]=++cnt;

         for(int i=;i<=n;i++)

             has[i]+=has[i-];

         for(int i=;i<=n;i++)

         {

             sa[has[str[i]]--]=i;

             rnk[i]=tmr[str[i]];

         }

         for(int k=;cnt!=n;k<<=)

         {

             cnt=;

             for(int i=;i<=n;i++)

                 has[i]=;

             for(int i=;i<=n;i++)

                 has[rnk[i]]++;

             for(int i=;i<=n;i++)

                 has[i]+=has[i-];

             for(int i=n;i;i--)

                 if(sa[i]>k)

                     tmr[sa[i]-k]=has[rnk[sa[i]-k]]--;

             for(int i=;i<=k;i++)

                 tmr[n-i+]=has[rnk[n-i+]]--;

             for(int i=;i<=n;i++)

                 sa[tmr[i]]=i;

             for(int i=;i<=n;i++)

                 if(Same(sa[i],sa[i-],k))

                     tmr[sa[i]]=cnt;

                 else

                     tmr[sa[i]]=++cnt;

             for(int i=;i<=n;i++)

                 rnk[i]=tmr[i];

         }

         for(int i=;i<=n;i++)

         {

             if(rnk[i]==)

                 continue;

             int j=std::max(,hgt[rnk[i-]]-);

             while(str[i+j-]==str[sa[rnk[i]-]+j-])

                 hgt[rnk[i]]=j++;

         }

         for(int i=;i<=n;i++)

             Rmq[][i]=hgt[i];

         for(int i=;i<=;i++)

             for(int j=;j+(<<i)-<=n;j++)

                 Rmq[i][j]=std::min(Rmq[i-][j],Rmq[i-][j+(<<(i-))]);

         return ;

     }

     int Lcp(int i,int j)

     {

         i=rnk[i],j=rnk[j];

         if(j<i)

             i^=j^=i^=j;

         i++;

         int l=lg[j-i+];

         return std::min(Rmq[l][i],Rmq[l][j-(<<l)+]);

     }

 }S1,S2;

 int tmp[N];

 int sln[N];

 int n,B;

 std::map<int,int>M;

 int main()

 {

     //freopen("a.in","r",stdin);

     scanf("%d%d",&n,&B);

     int cnt=;

     for(int i=;i<=n;i++)

         scanf("%d",&sln[i]);

     for(int i=n;i>=;i--)

         sln[i]-=sln[i-];

     for(int i=;i<=n;i++)

     {

         if(M.find(sln[i])==M.end())

             M[sln[i]]=++cnt;

         tmp[i-]=M[sln[i]];

     }

     S1.Insert(tmp,n-);

     S2.Reverse(tmp,n-);

     S1.Build();

     S2.Build();

     int ans=;

     for(int L=;L<=((n-)-B)/;L++)

     {

         for(int i=;i<=n-;i+=L)

         {

             int j=i+B+L;

             if(j>n-)

                 continue;

             int r=std::min(L,S1.Lcp(i,j));

             int l=std::min(L,S2.Lcp(n-i,n-j));

             int t=l+r-;

             if(t>=L)

                 ans+=t-L+;

         }

     }

     printf("%d\n",ans);

     return ;

 }