后缀数组

定义

1.sa[i]就表示排名为i的后缀的起始位置的下标
2.rk[i]就表示起始位置的下标为i的后缀的排名
3.LCP(i,j)为suff(sa[i])与suff(sa[j])的最长公共前缀
4.height[i]=LCP(i,i-1);
为什么要有LCP呢？ 🤔（后面会说）

定理

显而易见的
1.LCP(i,j)=LCP(j,i);
2.LCP(i,i)=len(sa[i])=n-sa[i]+1;
其他定理的证明：

SA基本过程

目的是求sa[i]和height[i].
1.快排(n log n)每个后缀，但是这是字符串，所以比较任意两个后缀的复杂度其实是O(n)，这样一来就是接近O(n^2 log n)的复杂度，数据大了肯定是不行的，所以我们这里有两个优化。
2.倍增log(n)
3.基数排序O(n)
求height[i]证明实在繁琐我就不细说了😒
总体复杂的O(n)log(n)

using namespace std;
typedef long long ll;
const int N=1e6+5;
int n,p,q,k,m;
int v[N],height[N];
int sa[2][N],rk[2][N];
char a[N];
///sa[p][i]表示排名为i的起始下标
///rk[p][i]表示起始下标为i的排名
///LCP(i,j)=suff(sa[i]),suff(sa[j]);
///height[i]表示LCP(i,i-1);
struct SA {
    void calsa(int sa[N],int rk[N],int SA[N],int RK[N]) {
        for(int i=1; i<=n; i++)v[rk[sa[i]]]=i;
        for(int i=n; i; i--)
            if(sa[i]>k)
                SA[v[rk[sa[i]-k]]--]=sa[i]-k;
        for(int i=n-k+1; i<=n; i++)SA[v[rk[i]]--]=i;
        for(int i=1; i<=n; i++)
            RK[SA[i]]=RK[SA[i-1]]+(rk[SA[i-1]]!=rk[SA[i]]||rk[SA[i]+k]!=rk[SA[i-1]+k]);
    }
    void getsa() {
        memset(v,0,sizeof(v));
        memset(rk,0,sizeof(rk));
        p=0,q=1;
        for(int i=1; i<=n; i++)v[a[i]]++;
        for(int i=1; i<=m; i++)v[i]+=v[i-1];
        for(int i=1; i<=n; i++)
            sa[p][v[a[i]]--]=i;
        for(int i=1; i<=n; i++)
            rk[p][sa[p][i]]=rk[p][sa[p][i-1]]+(a[sa[p][i-1]]!=a[sa[p][i]]);
        for(k=1; k<n; k<<=1,swap(p,q))
            calsa(sa[p],rk[p],sa[q],rk[q]);
    }
    void geth() {
        k=0;
        for(int i=1; i<=n; i++)
            if(rk[p][i]==1)height[rk[p][i]]=0;
            else {
                int j=sa[p][rk[p][i]-1];
                while(a[i+k]==a[j+k])k++;
                height[rk[p][i]]=k;
                if(k>0)k--;
            }
    }
    void init() {
        m=305;
        getsa();
        geth();
    }
} SA;

实例（子串=后缀的前缀）

 1.求不同子串个数 

 solution:考虑每个后缀贡献的前缀个数，
 即排名为i的后缀的贡献为n-sa[i]+1-height[i],
 用所有的前缀个数，减去与上一个排名的相同前缀个数。

2.给定 n 个值域在 [0,1000000] 的整数，
请求出最长的出现了至少 k 次的子串。

solution1:RMQ+SA
子串=后缀的前缀.
首先考虑：最长的子串的子串一定也出现了至少K次
那么我们就可以二分len,
每次检查长度=len的子串是否出现了K次。
height[i]=lcp(i，i-1）那么height[i]>=len不就
代表后缀的前缀出现了两次吗？
首先我们幻想一下height[i]数组的大小趋势大致是这个样子
大中小大小大中小,分段有序
那么我们要查询相邻的K段最小的那个height[i]取最大值就是答案

solution2:二分+SA
基于上一个solution,我们考虑这个check函数怎么写，
我们记录一段区间>=len的数量，大于k-1就行。

code:

bool judge(int len) {
    int cnt=0;
    for(int i=1; i<=n; i++) {
        if(height[i]<len)
            cnt=0;
        else cnt++;
        if(cnt>=K-1)return 1;
    }
    return 0;
}
void solve1() {
    int l=1,r=n,ans=0;
    while(l<=r) {
        int mid=(l+r)/2;
        if(judge(mid))
            ans=mid,l=mid+1;
        else
            r=mid-1;
    }
    cout<<ans<<endl;
}
void init() {
    for(int i=1; i<=n; i++) {
        dp[i][0]=height[i];
    }
    int up=log2(n);
    for(int j=1; j<=up; j++) {
        for(int i=1; i+(1<<j)-1<=n; i++) {
            dp[i][j]=min(dp[i][j-1],dp[i+(1<<(j-1))][j-1]);
        }
    }
}
int query(int x,int y) {
    int k=log2(y-x+1);
    return min(dp[x][k],dp[y-(1<<k)+1][k]);
}
void solve2() {
    init();
    int ans=0;
    for(int i=1; i<=n; i++) {
        ans=max(ans,query(i,i+K-1-1));
    }
    cout<<ans<<endl;
}
int main() {
    cin>>n>>K;
    for(int i=1; i<=n; i++)
        scanf("%d",&a[i]),d[i]=a[i];
    sort(d+1,d+n+1);
    int res=unique(d+1,d+n+1)-d-1;
    for(int i=1; i<=n; i++)
        a[i]=lower_bound(d+1,d+res+1,a[i])-d;
    SA.init();
    solve1();
    solve2();
}

3.求最长不重叠相似子串
相似子串是指：一个子串加上一个数字变成另一个字串

solution:变成相同子串我们会求，但是相似咋办呢？
我们可以做一个差分数组，求这个数组的SA。
跟上题二分差不多，记录连续区间的下标最小值和最大值
就能判断是否是重叠了。

bool judge(int len) {
    int mi=sa[p][1],ma=sa[p][1];
    for(int i=2; i<=n; i++) {
        if(height[i]<len) {
            mi=ma=sa[p][i];
        } else {
            mi=min(mi,sa[p][i]);
            ma=max(ma,sa[p][i]);
            if(ma-mi>=len)return 1;
        }
    }
    return 0;
}
void solve() {
    int l=0,r=n/2,ans=0;
    while(l<=r) {
        int mid=(l+r)/2;
        if(judge(mid))ans=mid,l=mid+1;
        else r=mid-1;
    }
    if(ans+1<=4)
        ans=-1;
    printf("%d\n",ans+1);
}
int main() {
    while(scanf("%d",&n)) {
        if(n==0)break;
        for(int i=1; i<=n; i++)
            scanf("%d",&a[i]);
        n--;
        for(int i=1; i<=n; i++)
            a[i]=a[i+1]-a[i]+100;
        a[n+1]=0;
        SA.init();
        solve();
    }
}