POJ 3693 Maximum repetition substring（后缀数组+ST）

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

解题思路：

从论文滚来做这题的-->https://wenku.baidu.com/view/5b886b1ea76e58fafab00374.html

理解大概是这样：（蓝字应该是循环两次，好像写错了，抱歉）

然后我们算出来的当前的答案不一定是这一组的最优解。

如  xbcabcab 这组数据（来自POJ 3693 的 discuss），我们在枚举L = 3的时候，按照上述方法我们得出的是cabcab，而实际上这部分字典序最小的是bcabca，因为求得的是当前需要补足位置的LCP，但实际上存在再前移一点仍然有解并且字典序更小的情况。

但是我们可以保证的是循环次数不会变多，因为再前移也不能超过L。所以通过上面的计算我们只能得出最大重复次数和对应的L，我们把所有重复次数最大的L都记录下来。（和明显记入答案的L是从小到大的）

然后接下来感觉是很暴力的操作，你要求字典序最小的答案，你就按照后缀的字典序排序（sa【】数组），枚举每个L，当前sa[i]对应后缀和后移L位的后缀的LCP是否>=L*最大重复次数，一旦有，这个就是字典序最小的答案了，因为我们保证了这是字典序最小并且长度最短的答案。

代码：

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<iostream>
#include<cmath>
#include<map>
#include<set>

using namespace std;

#define ll long long
#define for1(i,a,b) for (int i=a;i<=b;i++)
#define for0(i,a,b) for (int i=a;i<b;i++)
#define pb push_back
#define fi first
#define se second
#define debug(x) printf("----Line %s----\n",#x)
#define pt(x,y) printf("%s = %d\n",#x,y)
#define INF 0x3f3f3f3f

const int N = 1e5+5;

char s[N];
int wa[N],wb[N],rnk[N],height[N],sa[N],cnt[N],st[N][20],ans[N],idx;

void buildsa(int n,int m)
{
    int i,j,*x = wa,*y = wb,p;
    for0(i,0,m) cnt[i] = 0;
    for0(i,0,n) cnt[x[i]=s[i]]++;
    for0(i,1,m) cnt[i] += cnt[i-1];
    for (int i=n-1;i>=0;i--) sa[--cnt[x[i]]] = i;

    for (j=1,p=1;p<n;j<<=1,m=p){
        for (i=n-j,p=0;i<n;i++) y[p++] = i;
        for0(i,0,n) if (sa[i]>=j) y[p++] = sa[i]-j;

        for0(i,0,m) cnt[i] = 0;
        for0(i,0,n) cnt[x[y[i]]]++;
        for0(i,1,m) cnt[i] += cnt[i-1];
        for (int i=n-1;i>=0;i--) sa[--cnt[x[y[i]]]] = y[i];

        swap(x,y);
        x[sa[0]] = 0;
        p = 1;
        for (i=1;i<n;i++)
            x[sa[i]] = (y[sa[i]]==y[sa[i-1]] && y[sa[i]+j]==y[sa[i-1]+j])? p-1:p++;
    }
}

void getheight(int n)
{
    int k = 0;
    for0(i,0,n) rnk[sa[i]] = i;
    for0(i,0,n){
        if (rnk[i]==0){height[rnk[i]] = k = 0;continue;  }
        if (k) k--;
        int j = sa[rnk[i]-1];
        while (i+k<n && j+k<n && s[i+k]==s[j+k]) k++;
        height[rnk[i]] = k;
    }
}

void ST(int n)//1~len
{
    for1(i,1,n) st[i][0] = height[i];
    for (int j=1;(1<<j)<=n;j++)
        for (int i=1;i+(1<<j)-1<=n;i++)
            st[i][j] = min(st[i][j-1],st[i+(1<<(j-1))][j-1]);
}

int query(int l,int r)
{
    int k = log(r-l+1.0)/log(2);
    return min(st[l][k],st[r-(1<<k)+1][k]);
}

int main()
{
    int ica=1;
    while (~scanf("%s",s),s[0]!='#'){
        int len = strlen(s);
        buildsa(len+1,300);
        getheight(len+1);
        ST(len);
        idx = 0;
        int maxcnt = 0;

        for (int L = 1;L<=len;L++){
            for (int i=0;(i+1)*L<len;i++){
                int nowcnt = 0;
                int l = rnk[i*L],r = rnk[i*L+L];
                if (l>r) swap(l,r);
                int k = query(l+1,r);
                nowcnt = k/L+1;
                int re = k%L;///缀余
                re = L-re;///仍需匹配的长度
                if (re!=L){
                    l = rnk[i*L-re],r = rnk[i*L+L-re];
                    if (l>r) swap(l,r);
                    k = query(l+1,r);
                    if (k>=re) nowcnt++;
                }
                if (nowcnt>maxcnt){
                    idx = 0;
                    ans[idx++] = L;
                    maxcnt = nowcnt;
                }
                else if (nowcnt==maxcnt){
                    ans[idx++] = L;
                }
            }
        }

        int maxL=0,st;

        for0(i,1,len){
            if (maxL) break;
            for0(j,0,idx){
                int L = ans[j];
                if (sa[i]+L>len) continue;
                int l = rnk[sa[i]],r = rnk[sa[i]+L];
                if (l>r) swap(l,r);
                int k = query(l+1,r);
                if (k>=(maxcnt-1)*L){
                    st = sa[i];
                    maxL = L;
                    break;
                }
            }
        }

        printf("Case %d: ",ica++);
        for (int i = st;i<st+maxL*maxcnt;i++) printf("%c",s[i]);
        puts("");
    }
    return 0;
}

总结：单纯求最长重复次数复杂度还是O（nlogn），后面找字典序最小的复杂度到不了O（N*N）但是应该还是可以很大的。