SPOJ1812：LCS2 （后缀自动机）

题目传送门：http://www.spoj.com/problems/LCS2/

---

题目分析：在研究了陈老师的论文以及其他人写的SAM学习笔记一个周末之后，我终于A掉了人生中第一道SAM裸题……
作为入门题这道题应该还是很不错的。题意很简单（要求10个串的最长公共子串），而且思维难度和代码复杂度也不高。我们首先按照论文中的方法将一个串的SAM构出来，然后我们用其他串在上面跑就可以了（因为SAM本质上是将一个串的所有后缀做成AC自动机，并对其状态进行了化简，使其达到线性的时间和空间复杂度）。我们像AC自动机那样，从root向下走，如果当前节点没有某个儿子我们就沿着parent指针一路向上找。
那么如何得到答案呢？我们转移到一个新状态的时候，记录当前已经匹配的长度len，并将其和状态的R值取一个min（设当前状态right集合的区间是[L,R]）。为什么要取min呢？假设我们可以往前匹配R+1位，那么就超过了这个状态的表示范围，我们就不会转移到这个状态，而是转移到它在parent树上的某一个儿子。我们取完min之后更新这个状态的Max值（代表当前串在SAM上匹配到这个状态时，最长的公共子串长度）。然后我们再用一个Min值记录所有串匹配到此处时的Max的最小值，所有状态中最大的Min值即为答案。
在这里我们每匹配完一个串之后，还要将每个状态的Max值向其parent树上的父亲fa传递，因为每个状态的right集被它的父亲完全包含。注意传递的时候还要向fa->R取min。在这里我们按照每个状态在parent树上的深度由大到小传递即可（同时也是原SAM的拓扑序的逆序）。
那我们还要记录每个状态在parent树上的深度吗？其实不用。因为fa->R+1$=$node->L$<=$node->R，所以我们如果按R值从大到小做的话，在处理每一个状态的时候，它在parent树上的儿子都已经处理好了。在这里我们对R用一个桶排，就可以保证时间复杂度是线性的了。

---

CODE：

#include<iostream>
#include<string>
#include<cstring>
#include<cmath>
#include<cstdio>
#include<cstdlib>
#include<stdio.h>
#include<algorithm>
using namespace std;

const int maxn=100100;
const int maxc=26;

struct Tnode
{
    int R,Min,Max;
    Tnode *son[maxc],*parent;
} tree[maxn<<1];
Tnode *Root;
int cur=-1;

int cnt[maxn];
Tnode *rank[maxn<<1];

char s[maxn];
int ans=0;

Tnode *New_node()
{
    cur++;
    tree[cur].R=tree[cur].Max=0;
    tree[cur].Min=maxn;
    for (int i=0; i<maxc; i++) tree[cur].son[i]=NULL;
    tree[cur].parent=NULL;
    return tree+cur;
}

void Build()
{
    Root=New_node();
    Tnode *last=Root;

    int slen=strlen(s);
    for (int i=0; i<slen; i++)
    {
        int to=s[i]-'a';
        Tnode *NP=New_node();
        NP->R=i+1;

        Tnode *P=last;
        last=NP;
        while ( P && !P->son[to] ) P->son[to]=NP,P=P->parent;

        if (!P)
        {
            NP->parent=Root;
            continue;
        }

        Tnode *Q=P->son[to];
        if (Q->R==P->R+1) NP->parent=Q;
        else
        {
            Tnode *NQ=New_node();
            for (int j=0; j<maxc; j++) NQ->son[j]=Q->son[j];
            NQ->R=P->R+1;
            NQ->parent=Q->parent;

            Q->parent=NQ;
            NP->parent=NQ;
            while ( P && P->son[to]==Q ) P->son[to]=NQ,P=P->parent;
        }
    }

    for (int i=0; i<=cur; i++) cnt[ tree[i].R ]++;
    for (int i=1; i<maxn; i++) cnt[i]+=cnt[i-1];
    for (int i=0; i<=cur; i++) rank[ --cnt[ tree[i].R ] ]=tree+i;
}

void Match()
{
    Tnode *P=Root;
    int slen=strlen(s);
    int step=0;

    for (int i=0; i<slen; i++)
    {
        step++;
        int to=s[i]-'a';
        while ( P && !P->son[to] ) P=P->parent;
        if (!P) P=Root,step=0;
        else step=min(step,P->R+1),P=P->son[to];
        P->Max=max(P->Max,step);
    }

    for (int i=cur; i>=0; i--)
    {
        Tnode *P=rank[i],*F=P->parent;
        if (F) F->Max=max(F->Max, min(P->Max,F->R) );
        P->Min=min(P->Min,P->Max);
        P->Max=0;
    }
}

int main()
{
    freopen("c.in","r",stdin);
    freopen("c.out","w",stdout);

    scanf("%s",&s);
    Build();
    while ( ~scanf("%s",&s) ) Match();
    for (int i=0; i<=cur; i++) ans=max(ans,tree[i].Min);
    printf("%d\n",ans);

    return 0;
}