SPOJ 687 Repeats 后缀数组+暴力+rmq

题意：给出一个字符串，求出一个连续的重复次数最多的子串，并输出重复次数。

思路：后缀数组中的一个例题，思路里面已经提供了,但是里面只是写了思想。这里重新整理一下。

我们枚举所有的长度L。对于每个L，我们可以考察以r[i*L]开始,以r[(i+1)*L]为结束的子串的向前向后最长匹配长度。向后匹配，我们可以利用后缀数组求出的height来进行rmq.但是，向前匹配，该如何处理呢？应该想到，我们可以对待判定子串进行向前偏移，求偏移后的坐标的最长向后匹配，这就等价于原来子串的向前匹配的最大长度。

下面，我们就来确定向前偏移的大小。因为我们可以很容易的得到向后匹配的最大长度，但是可能会比L的整数倍多出几个字符。对于多匹配的这些字符，如果向前能够再凑出一个长度为L的匹配。这就是向前的最大匹配长度，即默认为我们考虑的子串是第一或第二个重复。（如果我们是从前到后考虑，必然可以保证如果是第三个或者是更大的重复，一定会在前面出现。）

在这个题中，我是第一次自己写后缀数组的rmq。感觉有以下注意点：

1.st表中，下标是从1开始的，查询是闭区间[l,r]。

2.st表中的顺序是后缀数组中的顺序，如果用字符串下标，需要利用rank数组来求出其在后缀数组的位置。

3.在height数组中，查询lcp的时候，我们要对左端点+1.

自己被坑的地方，就是用dc3会爆空间，但是spoj返回的是wa......

复杂度：核心算法的复杂度：n + n /2 + n /3 + n /4 + ... + 1 = O(nlgn)

代码如下：

#include <cstring>
#include <cstdio>
#include <algorithm>

using namespace std;

struct suffix_array{
    static const int maxn =100100;
    int rank[maxn],sa[maxn],height[maxn];
    int a[maxn],b[maxn],count[200000];
    //待排序字符串为r,长度为n,范围r[0] - r[n-1],值额范围0 - n-1.
    //字符集为m，范围1 - m;

    void radix_sort(int * r, int *a, int *b, int n, int m){//将a按照r进行基数排序，储存到b,长度为n，字符集为m
        memset(count,0,sizeof(count));
        for(int i = 0; i < n; ++i) ++count[r[a[i]]];
        for(int i = 1; i <= m; ++i) count[i] += count[i-1];
        for(int i = n -1; i >= 0; --i) b[--count[r[a[i]]]] = a[i];
    }

    void calc_sa(int*r, int n, int m){
        for(int i = 0; i < n; ++i) rank[i] =i;
        radix_sort(r,rank,sa,n,m);

        rank[sa[0]] = 0;
        for(int i = 1; i < n; ++i)
            rank[sa[i]]= rank[sa[i-1]] +(r[sa[i]]!=r[sa[i-1]]);
        for(int i = 0; 1<<i< n; ++i){
            for(int j = 0; j < n; ++j){
                a[j] = rank[j]+1;
                b[j] = j + (1<<i) >=n? 0: rank[j + (1<<i)] + 1;
                sa[j] = j;
            }
            radix_sort(b,sa,rank,n,n);
            radix_sort(a,rank,sa,n,n);
            rank[sa[0]] = 0;
            for(int j = 1; j < n; ++j){
                rank[sa[j]] = rank[sa[j-1]] + (a[sa[j-1]] != a[sa[j]] || b[sa[j-1]] != b[sa[j]]);
            }
        }
    }

    void calc_height(int * r,int n) {//计算height
        for(int i = 0 ; i < n; ++i) rank[sa[i]] = i;
        int h = 0;
        for(int i = 0; i < n; ++i){
            h = h == 0?0: h - 1;
            if(rank[i]!= 0)
                while(r[i + h] == r[sa[rank[i]-1] + h]) h++;
            height[rank[i]] = h;
        }
    }
    static const int MAX = 200100;
    int p[MAX];
    int d[MAX][20];
    void rmq_init(int n){
        p[0] = -1;
        for(int i = 1; i <= n; ++i)
            p[i] = i & (i-1)?p[i-1]:p[i-1]+1;
        for(int i = 1; i <= n; ++i) d[i][0] = height[i-1];
        for(int j = 1; j <= p[n]; ++j)
            for(int i = 1; i + (1 << j) - 1 <= n; ++i)
                d[i][j] = min(d[i][j-1],d[i+(1<<j-1)][j-1]);
    }
    int rmp_query(int l, int r){
        int k = p[r - l + 1];
        return min(d[l][k],d[r - (1<<k) + 1][k]);
    }
    int lcp(int l, int r){
        l = rank[l], r = rank[r];
        if(l > r) swap(l,r);l++;
        return rmp_query(l+1,r+1);
    }
    int solve(int n){
        int ret = 0;
        for(int l = 1; l < n; ++l){
            for(int i = 0; i + l < n; i += l){
                int ans = lcp(i,i+l);
                int j = i - (l - ans % l);
                ans = ans / l + 1;
                if(j >= 0 && lcp(j,j+l) >= l) ans++;
                ret = max(ret,ans);
            }
        }
        return ret;
    }

} solver;

int T,N;
char ch[2];
int r[100010];
int main(void)
{
    //freopen("input.txt","r",stdin);
    scanf("%d",&T);
    while(T--){
        scanf("%d",&N);
        for(int i = 0; i < N; ++i){
            scanf("%1s",ch);
            r[i] = ch[0];
        }
        solver.calc_sa(r,N,256);
        solver.calc_height(r,N);
        solver.rmq_init(N);
        //solver.print(r,N);
        printf("%d\n",solver.solve(N));
    }
    return 0;
}