\(\color{#0066ff}{ 題目描述 }\)

給定一個只包含小寫字母的字串\(S\),

請你求出 \(S\) 的所有出現次數不為 \(1\) 的子串的出現次數乘上該子串長度的最大值。

\(\color{#0066ff}{輸入格式}\)

一行一個僅包含小寫字母的字串\(S\)

\(\color{#0066ff}{輸出格式}\)

一個整數，為 所求答案

\(\color{#0066ff}{輸入樣例}\)

abab

\(\color{#0066ff}{輸出樣例}\)

4

\(\color{#0066ff}{資料範圍與提示}\)

對於\(10\%\)的資料，\(∣S∣\leq 1000\)

對於\(100\%\)

\(\color{#0066ff}{ 題解 }\)

字尾自動機是一個可以維護所有字串的最簡自動機

時間空間複雜度均為\(O(n)\)

是一個非常優秀的東西

本題要求出所有出現次數不為1的字串

那麼考慮parent樹

如果一個點所在子樹有大於1個葉子節點，就說明當前字串出現次數超過1（每個葉子都是字首）

但是我們parent樹只記錄了父親

沒有關係

不難發現，葉子節點維護的是一個字首，也就是字尾鏈上最長的

所以我們可以通過雞排來自下而上統計葉子個數

這題， 陣列大小開成偶數會TLE我也不知道為啥

#include<bits/stdc++.h>
using namespace std;
#define LL long long
LL in() {
    char ch; int x = 0, f = 1;
    while(!isdigit(ch = getchar()))(ch == '-') && (f = -f);
    for(x = ch ^ 48; isdigit(ch = getchar()); x = (x << 1) + (x << 3) + (ch ^ 48));
    return x * f;
}
const int maxn = 2e6 + 5;
struct SAM {
protected:
    struct node {
        node *ch[26], *fa;
        int len, siz;
        node(int len = 0, int siz = 0): fa(NULL), len(len), siz(siz) {
            memset(ch, 0, sizeof ch);
        }
    };
    node *root, *tail, *lst;
    node pool[maxn], *id[maxn];
    int c[maxn];
    void extend(int c) {
        node *o = new(tail++) node(lst->len + 1, 1), *v = lst;
        for(; v && !v->ch[c]; v = v->fa) v->ch[c] = o;
        if(!v) o->fa = root;
        else if(v->len + 1 == v->ch[c]->len) o->fa = v->ch[c];
        else {
            node *n = new(tail++) node(v->len + 1), *d = v->ch[c];
            std::copy(d->ch, d->ch + 26, n->ch);
            n->fa = d->fa, d->fa = o->fa = n;
            for(; v && v->ch[c] == d; v = v->fa) v->ch[c] = n;
        }
        lst = o;
    }
    void clr() {
        tail = pool;
        root = lst = new(tail++) node();
    }
public:
    SAM() { clr(); }
    void ins(char *s) { for(char *p = s; *p; p++) extend(*p - 'a'); }
    LL getans() {
        LL ans = 0; 
        int len = tail - pool, maxlen = 0;
        for(node *o = pool; o != tail; o++) c[o->len]++, maxlen = std::max(maxlen, o->len);
        for(int i = 1; i <= maxlen; i++) c[i] += c[i - 1];
        for(node *o = pool; o != tail; o++) id[--c[o->len]] = o;
        for(int i = len - 1; i; i--) {
            node *o = id[i];
            o->fa->siz += o->siz;
            if(o->siz > 1) ans = std::max(ans, 1LL * o->siz * o->len);
        }
        return ans;
    }
}sam;
int main() {
    static char s[maxn];
    scanf("%s", s);
    sam.ins(s);
    printf("%lld", sam.getans());
    return 0;
}