SPOJ Longest Common Substring II

Longest Common Substring II

Time Limit: 2000ms

Memory Limit: 262144KB

This problem will be judged on SPOJ. Original ID: LCS2
64-bit integer IO format: %lld      Java class name: Main

 

A string is finite sequence of characters over a non-empty finite set Σ.

In this problem, Σ is the set of lowercase letters.

Substring, also called factor, is a consecutive sequence of characters occurrences at least once in a string.

Now your task is a bit harder, for some given strings, find the length of the longest common substring of them.

Here common substring means a substring of two or more strings.

Input

The input contains at most 10 lines, each line consists of no more than 100000 lowercase letters, representing a string.

Output

The length of the longest common substring. If such string doesn't exist, print "0" instead.

Example

Input:
alsdfkjfjkdsal
fdjskalajfkdsla
aaaajfaaaa

Output:
2

解题：后缀自动机。。。。

#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
struct node {
    int son[26],f,len;
    void init() {
        f = -1;
        len = 0;
        memset(son,-1,sizeof son);
    }
};
struct SAM {
    node e[maxn<<1];
    int tot,last;
    void init() {
        tot = last = 0;
        e[tot++].init();
    }
    int newnode(int len = 0) {
        e[tot].init();
        e[tot].len = len;
        return tot++;
    }
    void extend(int c) {
        int p = last,np = newnode(e[p].len + 1);
        while(p != -1 && e[p].son[c] == -1) {
            e[p].son[c] = np;
            p = e[p].f;
        }
        if(p == -1) e[np].f = 0;
        else {
            int q = e[p].son[c];
            if(e[p].len + 1 == e[q].len) e[np].f = q;
            else {
                int nq = newnode();
                e[nq] = e[q];
                e[nq].len = e[p].len + 1;
                e[q].f = e[np].f = nq;
                while(p != -1 && e[p].son[c] == q) {
                    e[p].son[c] = nq;
                    p = e[p].f;
                }
            }
        }
        last = np;
    }
} sam;
int c[maxn],sa[maxn<<1],dp[maxn<<1];
char str[maxn];
int main() {
    sam.init();
    scanf("%s", str);
    int slen = strlen(str);
    for (int i = 0; i < slen; ++i) sam.extend(str[i] - 'a');
    for (int i = 1; i < sam.tot; ++i) c[sam.e[i].len]++;
    for (int i = 1; i <= slen; ++i) c[i] += c[i-1];
    for (int i = sam.tot-1; i > 0; --i) sa[c[sam.e[i].len]--] = i;
    node *ele = sam.e;
    while (scanf("%s", str) != EOF) {
        slen = strlen(str);
        int len = 0;
        for (int i = 0, p = 0; i < slen; ++i) {
            int c = str[i] - 'a';
            if (ele[p].son[c] != -1) {
                ++len;
                p = ele[p].son[c];
                dp[p] = max(len, dp[p]);
            } else {
                while (p != -1 && ele[p].son[c] == -1) p = ele[p].f;
                if (p != -1) {
                    len = ele[p].len + 1;
                    p = ele[p].son[c];
                    dp[p] = max(len, dp[p]);
                } else len = p = 0;
            }
        }
        for (int i = sam.tot-1; i > 0; --i) {
            int v = sa[i];
            ele[v].len = min(ele[v].len, dp[v]);
            dp[ele[v].f] = max(dp[ele[v].f], dp[v]);
            dp[v] = 0;
        }
    }
    int ans = 0;
    for (int i = 1; i < sam.tot; ++i)
        ans = max(ans, ele[i].len);
    printf("%d\n", ans);
    return 0;
}