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

題面描述 給定一些字串，求出它們的最長公共子串 輸入格式 輸入至多\(10\) 行，每行包含不超過\(100000\) 個的小寫字母，表示一個字串 輸出格式 一個數，最長公共子串的長度 若不存在最長公共子串，請輸出\(0\) 。

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

幾個字串

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

一個整數，為 所求答案

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

alsdfkjfjkdsal
fdjskalajfkdsla
aaaajfaaaa

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

2

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

none

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

對第一個字串建立SAM

每個點維護一個max，min ，分別代表當前字串匹配的最大len， 全域性匹配的最大len

匹配之前，雞排搞一下，方便遞推

每次匹配的時候，max清0， 匹配到哪，就用當前匹配長度len更新當前節點max

匹配完一個後，開始按順序（已經排好了）掃每個點，更新它的父親

他父親的max要跟min（父親的len， 當前的max）取max

因為葉子維護的是整個字首，所以不會存在超出的情況，但父親不一樣，要跟自己的len取min，然後跟自己的max取max挺繞的

最後跟所有節點去max就是ans了

#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 = 2e5 + 5;
const int inf = 0x7f7f7f7f;
struct SAM {
protected:
    struct node {
        node *ch[26], *fa;
        int len, siz, max, min;
        node(int len = 0, int siz = 0, int max = 0, int min = inf): fa(NULL), len(len), siz(siz), max(max), min(min) {
            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'); }
    void getid() {
        int 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;
    }
    void match(char *s) {
        node *o = root;
        int len = 0;
        for(char *p = s; *p; p++) {
            int pos = *p - 'a';
            if(o->ch[pos]) o = o->ch[pos], len++;
            else {
                while(o && !o->ch[pos]) o = o->fa;
                if(!o) o = root, len = 0;
                else len = o->len + 1, o = o->ch[pos];
            }
            o->max = std::max(o->max, len);
        }
        for(int i = tail - pool - 1; i; i--) {
            node *o = id[i];
            if(o->fa) o->fa->max = std::max(o->fa->max, std::min(o->max, o->fa->len));
            o->min = std::min(o->min, o->max);
            o->max = 0;
        }
    }
    int getans() {
        int ans = 0;
        for(int i = tail - pool - 1; i; i--) ans = std::max(ans, id[i]->min);
        return ans;
    }
}sam;
char s[maxn];
int main() {
    scanf("%s", s);
    sam.ins(s);
    sam.getid();
    while(~scanf("%s", s)) sam.match(s);
    printf("%d\n", sam.getans());
    return 0;
}