POJ 3261 Milk Patterns【后缀数组】可重叠的k次最长子串

Description

Farmer John has noticed that the quality of milk given by his cows varies from day to day. On further investigation, he discovered that although he can't predict the quality of milk from one day to the next, there are some regular patterns in the daily milk quality.

To perform a rigorous study, he has invented a complex classification scheme by which each milk sample is recorded as an integer between 0 and 1,000,000 inclusive, and has recorded data from a single cow over N (1 ≤ N ≤ 20,000) days. He wishes to find the longest pattern of samples which repeats identically at least K (2 ≤ K ≤ N) times. This may include overlapping patterns -- 1 2 3 2 3 2 3 1 repeats 2 3 2 3 twice, for example.

Help Farmer John by finding the longest repeating subsequence in the sequence of samples. It is guaranteed that at least one subsequence is repeated at least K times.

Input

Line 1: Two space-separated integers:  N and  K 
Lines 2..  N+1:  N integers, one per line, the quality of the milk on day  i appears on the  ith line.

Output

Line 1: One integer, the length of the longest pattern which occurs at least  K times

Sample Input

8 2
1
2
3
2
3
2
3
1

Sample Output

4

/*
    POJ 3261 Milk Patterns
    题意：给定一个字符串和k,求至少出现k次的最长重复子串,这k个子串可以重叠

    分析样例：8 2
              1 2 3 2 3 2 3 1
              在上面的序列,｛2 3 2 3｝为最长重复子串,所以答案输出4

    类型：后缀数组+二分

    分析：如果说至少出现k次这个限制条件去掉,即k=2,我们很容易就发现只要取height的最大值就是答案了
          例如：题目给的样例：1 2 3 2 3 2 3 1
          i      height       string            sa
          1             { 1 }                   7
                   1
          2             { 1 2 3 2 3 2 3 1 }     0
                   0
          3             { 2 3 1 }               5
                   2-------------------------------
          4             { 2 3 2 3 1 }           3
                   4
          5             { 2 3 2 3 2 3 1 }       1
                   0-------------------------------
          6             { 3 1 }                 6
                   1
          7             { 3 2 3 1 }             4
                   3
          8             { 3 2 3 2 3 1 }         2
          height_max = 4; 所以k=2时问题答案就是 4
          但是这道题有至少出现k次的限制条件,显然不能这么简单.假设k=3,那么上面的例子答案应该是2,{2, 3};
          按照后缀数组分组+2分的思想,然后看是否能够找到一组里面后缀的个数>=k的组：
          因为每组里面的height满足>=t,也就是说每组里面的最长公共前缀>=t,因为sa的不同,保证了不重复子串,
          这时只要满足组里面后缀的数目>=k,就保证了重叠的次数>=k,详细见下面演示：

          t = 2: 存在第3组里面后缀的个数>=3
          i      height       string            sa
          1             { 1 }                   7
                   1---------------------------------
          2             { 1 2 3 2 3 2 3 1 }     0
                   0---------------------------------
          3             { 2 3 1 }               5
                   2
          4             { 2 3 2 3 1 }           3
                   4
          5             { 2 3 2 3 2 3 1 }       1
                   0---------------------------------
          6             { 3 1 }                 6
                   1---------------------------------
          7             { 3 2 3 1 }             4
                   3
          8             { 3 2 3 2 3 1 }         2

          t = 3:不存在一组里面后缀的个数>=3
          i      height       string            sa
          1             { 1 }                   7
                   1---------------------------------
          2             { 1 2 3 2 3 2 3 1 }     0
                   0---------------------------------
          3             { 2 3 1 }               5
                   2---------------------------------
          4             { 2 3 2 3 1 }           3
                   4
          5             { 2 3 2 3 2 3 1 }       1
                   0---------------------------------
          6             { 3 1 }                 6
                   1---------------------------------
          7             { 3 2 3 1 }             4
                   3
          8             { 3 2 3 2 3 1 }         2
          所以最终答案是2.
*/
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
const int MAXN=20005;
int sa[MAXN];//sa[i]表示排在第i名的下标是多少,取值范围[1~n]
int rank[MAXN];//rank[i]表示以i为下标的后缀排在第几,取值范围[0~n-1]
int height[MAXN];//height[i]表示排在i-1名与排在第i名的最长公共前缀,取值范围[2~n]
int t1[MAXN],t2[MAXN],c[MAXN];//求sa数组需要的中间变量,不需要赋值初始化
int s[MAXN];
//待排序的字符串放在s数组中,从s[0]到s[n-1],长度为n,且最大值小于m.
//除s[n]为0 外的所有s[i]都大于0;函数结束以后结果放在sa数组中
void build_sa(int s[],int n,int m) //得到SA数组
{
    int i,j,p,*x=t1,*y=t2;
    for(i=0;i<m;i++)c[i]=0;
    for(i=0;i<n;i++)c[x[i]=s[i]]++;
    for(i=1;i<m;i++)c[i]+=c[i-1];
    for(i=n-1;i>=0;i--)sa[--c[x[i]]]=i;
    for(j=1;j<=n;j<<=1){
        p=0;
        for(i=n-j;i<n;i++)y[p++]=i;
        for(i=0;i<n;i++)if(sa[i]>=j)y[p++]=sa[i]-j;
        for(i=0;i<m;i++)c[i]=0;
        for(i=0;i<n;i++)c[x[y[i]]]++;
        for(i=1;i<m;i++)c[i]+=c[i-1];
        for(i=n-1;i>=0;i--)sa[--c[x[y[i]]]]=y[i];
        swap(x,y);
        p=1;x[sa[0]]=0;
        for(i=1;i<n;i++)
            x[sa[i]]=y[sa[i-1]]==y[sa[i]] && y[sa[i-1]+j]==y[sa[i]+j]?p-1:p++;
        if(p>=n)break;
        m=p;
    }
}
void getHeight(int s[],int n){ //得到height数组
    int i,j,k=0;
    for(i=0;i<=n;i++)rank[sa[i]]=i;
    for(i=0;i<n;i++){
        if(k)k--;
        j=sa[rank[i]-1];
        while(s[i+k]==s[j+k])k++;
        height[rank[i]]=k;
    }
}

bool check(int n,int t,int k)//判断每组中 每个后缀的sa值的最大值和最小值之差是否>=k
{
    int num=1;
    for(int i=2;i<=n;i++)
    {
        if(height[i]>=t){
            num++;
            if(num>=k)return true;
        }
        else num=1;
    }
    return false;
}
int main()
{
    //freopen("F:\\input.txt","r",stdin);
    int n,k;
    while(~scanf("%d%d",&n,&k))
    {
        int Max=-1;
        for(int i=0;i<n;i++)
        {
            scanf("%d",&s[i]);
            if(s[i]>Max)Max=s[i];
        }
        s[n]=0;                 //s[n]置为0
        build_sa(s,n+1,Max+1);
        getHeight(s,n);
        int ans=-1;
        int l=1,r=n;
        while(l<=r)             //二分组数t
        {
            int mid=(l+r)/2;
            if(check(n,mid,k))
            {
                ans=mid;
                l=mid+1;
            }
            else r=mid-1;
        }
        printf("%d\n",ans);
    }
    return 0;
}