[SPOJ-NSUBSTR]Substrings

题目大意：
　　给你一个字符串s，求出不同长度出现次数最多的字串的最大出现次数。

思路：
　　先对s构造后缀自动机，然后把s放进去匹配，每一个经过的结点表示一种长度的子串，用一个cnt记录能以每个状态表示的子串数量，然后按拓扑序DP。
　　注意拓扑序并不等同于在SAM中插入的次序，因为用new_q替代q的操作会打乱顺序。（上一道题可能是因为数据弱被我卡过去了）
　　然后我想到了DFS，以为从根结点开始得到的DFS序就是拓扑序，然而这样会忽略那些不是任何状态的后继状态，但是有link指针的状态（它们同样可以向上传递）。
　　参考了网上的题解，发现常用的SAM拓扑排序方法很简单，直接按照每个状态到根结点的最长距离len排序即可。
　　然而这样遍历每个状态肯定是连续的在一个数组中比较方便，然而我是用的指针（学陈立杰），于是又用数组模拟指针。
　　然后还是WA。
　　后来发现是指针改写成数组模拟的时候把pq打反了。

 

#include<cstdio>
#include<cstring>
#include<algorithm>
const int LEN=250001;
class SuffixAutomaton {
    private:
        static const int SIGMA_SIZE=26;
        int cnt[LEN],len,sz;
        struct State {
            int link,go[SIGMA_SIZE];
            int len,cnt;
        };
        State s[LEN<<1];
        int newState(const int l) {
            sz++; 
            s[sz].link=NULL;
            memset(s[sz].go,0,sizeof s[sz].go);
            s[sz].len=l;
            s[sz].cnt=0;
            return sz;
        }
        int root,last;
        int top[LEN<<1];
        int idx(const char ch) {
            return ch-'a'; 
        }
        void extend(const char ch) {
            const int w=idx(ch);
            int p=last;
            int new_p=newState(s[p].len+1);
            while(p!=NULL&&s[p].go[w]==NULL) {
                s[p].go[w]=new_p;
                p=s[p].link;
            }
            if(p==NULL) {
                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[new_p].link=s[q].link=new_q;
                    while(p!=NULL&&s[p].go[w]==q) {
                        s[p].go[w]=new_q;
                        p=s[p].link;
                    }
                }
            }
            last=new_p;
        }
        void match(char ss[]) {
            int p=root;
            for(int i=0;i<len;i++) {
                p=s[p].go[idx(ss[i])];
                s[p].cnt++;
            }
        }
        int f[LEN];
    public:
        void build(char s[]) {
            len=strlen(s);
            root=last=newState(0);
            for(int i=0;i<len;i++) {
                extend(s[i]);
            }
        }
        void query(char ss[]) {
            match(ss);
            for(int i=1;i<=sz;i++) cnt[s[i].len]++;
            for(int i=len;i;i--) cnt[i-1]+=cnt[i];
            for(int i=sz;i;i--) top[cnt[s[i].len]--]=i;
            for(int i=1;i<=sz;i++) {
                if(s[top[i]].link!=NULL) {
                    s[s[top[i]].link].cnt+=s[top[i]].cnt;
                }
            }
            for(int i=1;i<=sz;i++) {
                f[s[top[i]].len]=std::max(f[s[top[i]].len],s[top[i]].cnt);
            }
            for(int i=len;i;i--) {
                f[i]=std::max(f[i],f[i+1]);
            }
            for(int i=1;i<=len;i++) printf("%d\n",f[i]);
        }
};
SuffixAutomaton sam;
char s[LEN];
int main() {
    scanf("%s",s);
    sam.build(s);
    sam.query(s);
    return 0;
}