[POJ1743]Musical Theme

题目大意：
　　给你一个数列，我们数列中两个串是相似的当且仅当这两个串的长度至少为5、两个串差分后形成的数列一样且不相交，求最长的相似串的长度。

思路：
　　后缀自动机求最长不相交重复子串。
　　首先将差分后的数列构造SAM，然后按照拓扑序DP，得到每个状态right集合的最大值t与最小值s，表示当前状态对应的最长的不相交子串为[s,t]。
　　然而我们还要保证以当前状态结尾的子串的长度能够与[s,t]子串相等，设当前状态对应的最长子串长度为len，则最长相似串的长度为min(t-s+1,len) 。
　　然后取max即可。

#include<cstdio>
#include<cctype>
#include<cstring>
#include<algorithm>
inline int getint() {
    char ch;
    while(!isdigit(ch=getchar()));
    int x=ch^'0';
    while(isdigit(ch=getchar())) x=(((x<<2)+x)<<1)+(ch^'0');
    return x;
}
const int inf=0x7fffffff;
const int LEN=20001;
int n;
class SuffixAutomaton {
    private:
        static const int SIGMA_SIZE=180;
        struct State {
            int link,go[SIGMA_SIZE],len,maxright,minright;
        };
        State s[LEN<<1];
        int sz,newState(const int l) {
            sz++;
            s[sz].len=l;
            s[sz].minright=inf;
            return sz;
        }
        int root,last;
        int cnt[LEN],top[LEN<<1];
        void tsort() {
            for(int i=1;i<=sz;i++) cnt[s[i].len]++;
            for(int i=n;i;i--) cnt[i-1]+=cnt[i];
            for(int i=1;i<=sz;i++) top[cnt[s[i].len]--]=i;
        }
    public:
        void reset() {
            sz=0;
            memset(s,0,sizeof s);
            root=last=newState(0);
            memset(cnt,0,sizeof cnt);
        }
        void extend(const int w) {
            int p=last,new_p=newState(s[last].len+1);
            s[new_p].maxright=s[new_p].minright=s[new_p].len;
            while(p&&!s[p].go[w]) {
                s[p].go[w]=new_p;
                p=s[p].link;
            }
            if(!p) {
                s[new_p].link=root;
            } else {
                int q=s[p].go[w];
                if(s[q].len==s[p].len+1) {
                    s[new_p].link=q;
                } else {
                    int new_q=newState(s[p].len+1);
                    memcpy(s[new_q].go,s[q].go,sizeof s[q].go);
                    s[new_q].link=s[q].link;
                    s[q].link=s[new_p].link=new_q;
                    while(p&&s[p].go[w]==q) {
                        s[p].go[w]=new_q;
                        p=s[p].link;
                    }
                }
            }
            last=new_p;
        }
        int stat() {
            tsort();
            for(int i=1;i<=sz;i++) {
                int p=top[i],q=s[top[i]].link;
                s[q].maxright=std::max(s[q].maxright,s[p].maxright);
                s[q].minright=std::min(s[q].minright,s[p].minright);
            }
            int ret=0;
            for(int i=1;i<=sz;i++) {
                ret=std::max(ret,std::min(s[i].maxright-s[i].minright+1,s[i].len+1));
            }
            return ret>=5?ret:0;
        }
};
SuffixAutomaton sam;
int s[LEN];
int main() {
    for(;;) {
        n=getint();
        if(!n) return 0;
        sam.reset();
        for(int i=1;i<=n;i++) s[i]=getint();
        for(int i=1;i<n;i++) sam.extend(s[i]=s[i+1]-s[i]+88);
        printf("%d
",sam.stat());
    }
}