SPOJ NSUBSTR Substrings - 后缀自动机

题目传送门

　　传送站I

　　传送站II

题目大意

　　给定一个字符串$S$，问对于任意整数$1\leqslant x\leqslant |S|$，长度为$x$的串最多出现了多少次。

　　众所周知，我们可以用后缀自动机来求子串出现的次数。

　　在parent树上，叶节点向根节点累加$cnt$。想想这样做的本质，就是求出了每个状态的$Right$集合的大小。

　　根据parent指针的定义，子节点的Right集合是它的parent的Right集合的真子集，并且最短长度大于它的parent的最长长度。

　　所以，每次修改区间$[l, r]$的最大值，可以看成直接修改$[1, r]$。因此，可以差分一下，每次单点修改，最后做一次后缀和。

　　时间复杂度$O(|S|)$

Code

/**
 * SPOJ
 * Problem#NSUBSTR
 * Accepted
 * Time: 270ms
 * Memory: 89088k
 */
#include <bits/stdc++.h>
using namespace std;
typedef bool boolean;
#define smax(_a, _b) ((_a < _b) ? (_a = _b) : (0))

const int N = 5e5 + 5, alpha = 26;

typedef class TrieNode {
    public:
        int len, cnt;
//        TrieNode* ch[26];
        map<int, TrieNode*> ch;
        TrieNode* fail;
}TrieNode;

TrieNode pool[N];
TrieNode* sp[N];
TrieNode* top = pool;

TrieNode* newnode(int len) {
    top->len = len;
    return top++;
}

typedef class SuffixAutomaton {
    public:
        TrieNode* rt;
        TrieNode* last;

        SuffixAutomaton() {
            last = rt = newnode(0);
        }

        void extend(char x) {
            int c = x - 'a';
            TrieNode *f = last, *p = newnode(last->len + 1);
            while (f && !f->ch[c])
                f->ch[c] = p, f = f->fail;
            if (!f)
                p->fail = rt;
            else {
                TrieNode* q = f->ch[c];
                if (q->len == f->len + 1)
                    p->fail = q;
                else {
                    TrieNode* nq = newnode(f->len + 1);
                    nq->fail = q->fail, q->fail = nq, p->fail = nq;
                    nq->ch = map<int, TrieNode*>(q->ch);
                    while (f && f->ch[c] == q)
                        f->ch[c] = nq, f = f->fail;
                }
            }
            last = p, p->cnt = 1;
        }
}SuffixAutomaton;

int n;
char str[N];
int cnt[N], f[N];
SuffixAutomaton sam;

inline void init() {
    scanf("%s", str + 1);
    n = strlen(str + 1);
}

inline void solve() {
    for (int i = 1; i <= n; i++)
        sam.extend(str[i]);
//    for (TrieNode* p = pool; p < top; p++)
//        cerr << p - pool << " " << p->fail - pool << " " << p->len << " " << p->cnt << endl;
    for (TrieNode* p = pool + 1; p < top; p++)        cnt[p->len]++;
    for (int i = 2; i <= n; i++)        cnt[i] += cnt[i - 1];
    for (int i = 1; pool + i < top; i++)        sp[cnt[pool[i].len]--] = pool + i;
    for (int i = top - pool - 1; i; i--)    sp[i]->fail->cnt += sp[i]->cnt;
    for (int i = 1; pool + i < top; i++)    smax(f[sp[i]->len], sp[i]->cnt);
    for (int i = n; i > 1; i--)    smax(f[i - 1], f[i]);
    for (int i = 1; i <= n; i++)
        printf("%d\n", f[i]);
}

int main() {
    init();
    solve();
    return 0;
}