SPOJ LCS2 后缀自动机

题意

给多个字符串，问最长公共子串。

题解

最长公共子串用后缀自动机还是很方便的，首先的话，有一个非常重要的后缀自动机性质一定要明确，后缀自动机一个点的par一定是这个点代表的所有字符子串的公共后缀。了解了这一点，我们便可以构造后缀自动机，然后进行匹配。
在匹配的过程中，如果可以成功转移，直接转移并且把记录的长度++就可以了。如果不可以成功转移，那么就需要去进行失配匹配。这时候后缀自动机的方便性就很好的体现出来了，如果失配的话，直接转移到par点就可以了，因为par点是这个点所有子串的公共最大后缀，因此转移到par点是最合理的选择。这样的话，如果可行的话，就把匹配长度赋为len[par]+1。否则继续进行失配匹配。
上述讲解是针对LCS那道题的，这道题相比于LCS又麻烦一点。这道题是求多个串的公共子串。那么我们首先需要记录一下转移到每个点的最大匹配长度，这里需要注意的是，在匹配的过程中有可能没有经过par点，但是由于实际上字符串是包含par点的，所以需要处理一下，将经过的par点的匹配长度赋为len[par]。然后我们要针对每一个点选择最小的匹配长度，这样才是所有字符串的公共子串。
最后的话，我们选择所有公共匹配长度中最大的作为结果就可以了。

注意事项

需要对匹配过程十分注意，如果失配到0以后，u的值要赋为1（也就是root）。如果赋为0的话，会WA ON TEST 3。

代码

#include<bits/stdc++.h>
#define UP(i,l,h) for(int i=l;i<h;i++)
#define DOWN(i,h,l) for(int i=h-1;i>=l;i--)
#define W(a) while(a)
#define MEM(a,b) memset(a,b,sizeof(a))
#define LL long long
#define INF 0x3f3f3f3f
#define MAXN 200050
#define MOD 1000000007
#define EPS 1e-3
using namespace std;
char s[MAXN];
struct SuffixAuto {
    static const int NODE=MAXN<<1,C=26;
    int allc,last,n,par[NODE],len[NODE],trans[NODE][C],c[NODE],rt[NODE],id[NODE],ans[NODE],mx[NODE];
    int newNode() {
        int now=++allc;
        MEM(trans[now],0);
        return now;
    }
    void init(int x) {
        MEM(c,0);
        MEM(rt,0);
        MEM(id,0);
        MEM(ans,INF);
        allc=0;
        n=x;
        last=newNode();
        par[last]=len[last]=0;
    }
    void extend(int c) {
        int p=last,np=newNode();
        len[np]=len[last]+1;
        for(; p&&!trans[p][c]; p=par[p]) trans[p][c]=np;
        if(!p) par[np]=1;
        else {
            int q=trans[p][c];
            if(len[q]==len[p]+1) par[np]=q;
            else {
                int nq=++allc;
                par[nq]=par[q],len[nq]=len[p]+1;
                memcpy(trans[nq],trans[q],sizeof(trans[q]));
                par[np]=par[q]=nq;
                for(trans[p][c]=nq,p=par[p]; p&&trans[p][c]==q; p=par[p]) trans[p][c]=nq;
            }
        }
        last=np;
    }
    void countSort() {
        UP(i,1,allc+1) c[len[i]]++;
        UP(i,1,n+1) c[i]+=c[i-1];
        UP(i,1,allc+1) id[c[len[i]]--]=i;
        DOWN(i,allc+1,1) rt[par[id[i]]]+=rt[id[i]];
    }
    void find(char *st) {
        int stlen=strlen(st);
        int u=1;
        int now=0;
        MEM(mx,0);
        UP(i,0,stlen) {
            int x=st[i]-'a';
            if(trans[u][x]) {
                now++;
                u=trans[u][x];
            } else {
                W(u&&!trans[u][x]) u=par[u];
                if(u) {
                    now=len[u]+1;
                    u=trans[u][x];
                } else {
                    now=0;
                    u=1;
                }
            }
            mx[u]=max(mx[u],now);
        }
        DOWN(i,allc+1,1) if(mx[id[i]]) mx[par[id[i]]]=len[par[id[i]]];
        UP(i,1,allc+1) {
            ans[i]=min(ans[i],mx[i]);
//            cout<<"a "<<ans[i]<<" "<<i<<endl;
        }
    }
};
SuffixAuto sa;

int main() {
    scanf("%s",s);
    int len=strlen(s);
    sa.init(len);
    UP(i,0,len) sa.extend(s[i]-'a');
    sa.countSort();
    W(~scanf("%s",s)) {
        sa.find(s);
    }
    int ans=0;
    UP(i,1,sa.allc+1) if(sa.ans[i]<INF) ans=max(ans,sa.ans[i]);
    printf("%d\n",ans);
}
/*
a
abc
abcabc
*/