[poj 3693]后缀数组+出现次数最多的重复子串

题目链接：http://poj.org/problem?id=3693

枚举长度L，看长度为L的子串最多能重复出现几次，首先，能出现1次是肯定的，然后看是否能出现两次及以上。由抽屉原理，这个子串出现次数>=2，那么必定会覆盖s[0],s[L],s[2L],...中相邻的两个，枚举是哪两个。对于覆盖了这两个的重复子串，它重复的次数就是看这两个后缀向前向后各自最多能匹配到多远。假设向前向后共匹配了长度K，那么重复的次数就是K/L+1。

这里有3个问题.

第一个，为什么先前向后各自匹配就可以了？因为子串长度就是L，枚举的这两个位置的距离也是L，那么这两个位置必定得是相同的。

第二个问题，怎么看向前最多匹配多少？向后的话直接通过height数组即可实现，而向前呢？难道要倒着再做一次后缀数组？（当然也不是不可行）事实上不用这么麻烦，直接考虑我们要求的结果K/L+1。利用整除的特性其实很容易得到这个结果。比如我们向后最多匹配L1。现在我们想知道结果能不能比L1/L+1来的大，怎么办呢？考虑L-L1%L，这个数代表L1至少要加几，才会让结果有所增加。那么显然向前距离在这个数以内的我们都不用检验了，因为即使检验到能匹配也没啥用，对结果没啥影响。所以我们检验一下距离是这个数的两个后缀的匹配长度，如果能匹配就更新一下结果。那么距离在这个数以外的呢？其实也不用检验了，如果说距离在这个数以外的还能让结果增加，那必须得再+L，再+L的话其实不必检验了，因为如果能匹配，在之前的求解（上次的枚举）中已经检验过了。因此，只检验一个位置即可。

第三个问题，怎么得到字典序最小的那一组解。通过sa数组的顺序枚举。不过得稍微优化一下，不能所有长度都尝试，不然会T。

穷举长度 L 的时间是 n，每次计算的时间是 n/L。所以整个做法的时间复杂度是 O(n/1+n/2+n/3+……+n/n)=O(nlogn)。（假设查询最长公共前缀的复杂度是O(1)，用rmq预处理可以做到）

#include<algorithm>
#include<cstdio>
#include<cstring>
using namespace std;

const int MAXN = ;
#define F(x) ((x)/3+((x)%3==1?0:tb))
#define G(x) ((x)<tb?(x)*3+1:((x)-tb)*3+2)
int wa[MAXN*],wb[MAXN*],wv[MAXN*],wss[MAXN*];
int c0(int *r,int a,int b)
{
    return r[a] == r[b] && r[a+] == r[b+] && r[a+] == r[b+];
}
int c12(int k,int *r,int a,int b)
{
    if(k == )
        return r[a] < r[b] || ( r[a] == r[b] && c12(,r,a+,b+) );
    else return r[a] < r[b] || ( r[a] == r[b] && wv[a+] < wv[b+] );
}
void sort(int *r,int *a,int *b,int n,int m)
{
    int i;
    for(i = ; i < n; i++)wv[i] = r[a[i]];
    for(i = ; i < m; i++)wss[i] = ;
    for(i = ; i < n; i++)wss[wv[i]]++;
    for(i = ; i < m; i++)wss[i] += wss[i-];
    for(i = n-; i >= ; i--)
        b[--wss[wv[i]]] = a[i];
}
void dc3(int *r,int *sa,int n,int m)
{
    int i, j, *rn = r + n;
    int *san = sa + n, ta = , tb = (n+)/, tbc = , p;
    r[n] = r[n+] = ;
    for(i = ; i < n; i++)if(i % != )wa[tbc++] = i;
    sort(r + , wa, wb, tbc, m);
    sort(r + , wb, wa, tbc, m);
    sort(r, wa, wb, tbc, m);
    for(p = , rn[F(wb[])] = , i = ; i < tbc; i++)
        rn[F(wb[i])] = c0(r, wb[i-], wb[i]) ? p -  : p++;
    if(p < tbc)dc3(rn,san,tbc,p);
    else for(i = ; i < tbc; i++)san[rn[i]] = i;
    for(i = ; i < tbc; i++) if(san[i] < tb)wb[ta++] = san[i] * ;
    if(n %  == )wb[ta++] = n - ;
    sort(r, wb, wa, ta, m);
    for(i = ; i < tbc; i++)wv[wb[i] = G(san[i])] = i;
    for(i = , j = , p = ; i < ta && j < tbc; p++)
        sa[p] = c12(wb[j] % , r, wa[i], wb[j]) ? wa[i++] : wb[j++];
    for(; i < ta; p++)sa[p] = wa[i++];
    for(; j < tbc; p++)sa[p] = wb[j++];
}
void da(int str[],int sa[],int rank[],int height[],int n,int m)
{
    for(int i = n; i < n*; i++)
        str[i] = ;
    dc3(str, sa, n+, m);
    int i,j,k = ;
    for(i = ; i <= n; i++)rank[sa[i]] = i;
    for(i = ; i < n; i++)
    {
        if(k) k--;
        j = sa[rank[i]-];
        while(str[i+k] == str[j+k]) k++;
        height[rank[i]] = k;
    }
}

int str[MAXN*3],sa[MAXN*3],rk[MAXN],height[MAXN];
int RMQ[MAXN];
int mm[MAXN];
int best[][MAXN];
void initRMQ(int n)
{
    mm[]=-;
    for(int i=; i<=n; i++)
        mm[i]=((i&(i-))==)?mm[i-]+:mm[i-];
    for(int i=; i<=n; i++)best[][i]=i;
    for(int i=; i<=mm[n]; i++)
        for(int j=; j+(<<i)-<=n; j++)
        {
            int a=best[i-][j];
            int b=best[i-][j+(<<(i-))];
            if(RMQ[a]<RMQ[b])best[i][j]=a;
            else best[i][j]=b;
        }
}
int askRMQ(int a,int b)
{
    int t;
    t=mm[b-a+];
    b-=(<<t)-;
    a=best[t][a];
    b=best[t][b];
    return RMQ[a]<RMQ[b]?a:b;
}
int lcp(int a,int b)
{
    a=rk[a];
    b=rk[b];
    if(a>b)swap(a,b);
    return height[askRMQ(a+,b)];
}

char s[MAXN];
int cou;
int l;
int a[MAXN];
int cnt=;

int main()
{
    int cas=;
    while (~scanf("%s",s) && s[]!='#')
    {
        l=strlen(s);
        for (int i=; i<l; i++) str[i]=s[i]-'a'+;
        str[l]=;
        da(str,sa,rk,height,l,);
//        for (int i=0;i<l;i++) printf("%d ",rk[i]);
        for (int i=;i<=l;i++) RMQ[i]=height[i];
        initRMQ(l);
        cou=;
        cnt=;
        a[cnt++]=;
        for (int L=; L<=l/; L++)
        {
            for (int j=; j+L<l; j+=L)
            {
                int back=lcp(j,j+L);
//                printf(":%d:\n",back);
                if (back/L+>cou)
                {
                    cou=back/L+;
                    cnt=;
                    a[cnt++]=L;
                }
                else if (back/L+==cou) a[cnt++]=L;
                int check=L-back%L;
                if (check!=L && j-check>=)
                {
                    int pre=lcp(j-check,j-check+L);
//                    printf(":%d:\n",pre);
                    if (pre/L+>cou)
                    {
                        cou=pre/L+;
                        cnt=;
                        a[cnt++]=L;
                    }
                    else if (pre/L+==cou) a[cnt++]=L;
                }
            }
        }
//        printf("::%d\n",cou);
        int ansp=-;
        int ansl=-;
//        for (int i=1;i<=l;i++) printf("%d ",sa[i]);
        for (int i=; i<=l&&ansp==-; i++)
        {
            int j=sa[i];
            for (int k=; k<cnt&&a[k]<=(l-j)/cou; k++)
            {
                if (j+a[k]<l && lcp(j,j+a[k])/a[k]+>=cou)
                {
//                    printf("QAQ\n");
                    ansp=j;
                    ansl=a[k];
                    break;
                }
            }
        }
        s[ansp+ansl*cou]=;
//        printf("%d %d\n",ansp,ansl);
        printf("Case %d: %s\n",++cas,s+ansp);
    }
    return ;
}