[SPOJ1812]-LCS2-后缀自动机

说在前面

并没有什么想说的，但是要保持格式=w=

---

题目

SPOJ - LCS2传送门

题目大意

给出N个字符串（N不超过10，每个串长不超过100000），求出这N个字符串的最长公共子串
（Tip：子串是连续的，子序列是不连续的）

输入输出格式

输入格式：
一共N行，每行包含一个字符串

输出格式：
输出一行一个整数，表示最长公共子串

---

解法

这是一道后缀自动姬的基础应用题=w=
首先拿一个串来建立后缀自动姬，然后用其它的串在这个自动姬上匹配。
匹配的时候维护一个cnt表示当前匹配的长度。如果能够匹配就一直走，并且cnt加一；不能走就跳parent边，直到跳到一个有当前字符转移边的节点，然后把cnt设为当前节点的max_length，继续匹配。匹配完之后，自底向上更新每个节点的「节点当前最大匹配长度」（注意匹配长度不能超过max_length），然后用「节点当前最大匹配长度」去更新「节点全局匹配长度」。最后在这个 全局匹配长度 里取个max就是答案

关于跳parent的正确性，因为right集合之间是互相包含的，所以如果能走到当前节点，就表示至少min_len的长度被匹配上了，而parent的max_len是当前节点的min_len-1，所以parent也一定能匹配，而且可以匹配完。
当前串最大匹配长度，只是当前这一个串在后缀自动姬上跑出来的匹配长度，而要求的是所有串的公共子串，因此就定义了「节点当前最大匹配长度」和「节点全局匹配长度」这两个数组

---

下面是自带大常数的代码

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std ;

int N , id_c , ans ;
int Max[200005] , Min[200005] ;
char ss[100005] ;
struct Node{
    int len , id ;
    Node *ch[26] , *par ;
}w[200005] , *tw = w , *root , *last ;

void newNode( Node *&nd , int len ){
    nd = ++tw ;
    nd->id = ++id_c ;
    nd->len = len ;
}

void Insert( char cc ){
    Node *nd , *tmp = last ;
    newNode( nd , tmp->len + 1 ) ;
    short id = cc - 'a' ;

    for( ; tmp && !tmp->ch[id] ; tmp = tmp->par )
        tmp->ch[id] = nd ;
    if( !tmp ) nd->par = root ;
    else{
        Node *B = tmp->ch[id] ;
        if( tmp->len + 1 == B->len ) nd->par = B ;
        else{
            Node *nB ; newNode( nB , tmp->len + 1 ) ;
            memcpy( nB->ch , B->ch , sizeof( nB->ch ) ) ;
            nB->par = B->par ;
            B->par = nd->par = nB ;
            while( tmp && tmp->ch[id] == B ){
                tmp->ch[id] = nB ;
                tmp = tmp->par ;
            }
        }
    }
    last = nd ;
}

int tp[200005] , sa[200005] ;
void Rsort(){
    for( int i = 1 ; i <= id_c ; i ++ ) tp[ w[i].len ] ++ ;
    for( int i = 1 ; i <= N ; i ++ ) tp[i] += tp[i-1] ;
    for( int i = id_c ; i ; i -- ) sa[ tp[w[i].len] -- ] = i ;
}

void RUN(){
    Node *nd = root ;
    int len = 0 ;
    memset( Max , 0 , sizeof( Max ) ) ;
    for( int i = 1 ; i <= N ; i ++ ){
        int id = ss[i] - 'a' ;
        if( nd->ch[id] )
            len ++ , nd = nd->ch[id] ;
        else{
            while( nd && !nd->ch[id] ) nd = nd->par ;
            if( !nd ) len = 0 , nd = root ;
            else      len = nd->len + 1 , nd = nd->ch[id] ;
        }
        Max[ nd->id ] = max( Max[ nd->id ] , len ) ;
    //  printf( "Max[%d] is %d\n" , nd->id , Max[ nd->id ] ) ;
    }
    for( int i = id_c ; i > 1 ; i -- ){
        Node *nd = ( w + sa[i] ) ;
        if( Max[ nd->id ] ) Max[ nd->par->id ] = nd->par->len ;
    }
    for( int i = 2 ; i <= id_c ; i ++ )
        Min[i] = min( Min[i] , Max[i] ) ;
}

int main(){
    newNode( root , 0 ) ; last = root ;
    scanf( "%s" , ss + 1 ) ; N = strlen( ss + 1 ) ;
    for( int i = 1 ; i <= N ; i ++ ) Insert( ss[i] ) ;
    Rsort() ;

    memset( Min , 0x3f , sizeof( Min ) ) ;
    while( scanf( "%s" , ss + 1 ) != EOF ){
        N = strlen( ss + 1 ) ;
        RUN() ;
    }
    for( int i = 2 ; i <= id_c ; i ++ )
        ans = max( Min[i] , ans ) ;
    printf( "%d" , ans == Min[0] ? 0 : ans ) ;
}