[SPOJ-LCS2]Longest Common Substring II

题目大意：
　　求若干个字符串的LCS。

思路：
　　对于第一个字符串构造SAM，然后把后面的字符串放在SAM中匹配，对于同一个字符串匹配到的同一个状态，记录其匹配长度之max，
　　然后对于不同的字符串匹配到的同一个状态，记录其匹配长度之min，然后对于所有的状态取max。
　　然而这样只能过9个点，第10个点会WA，原因是如果不同的字符串匹配到的同一个字串，可能并不在SAM的同一个状态上，
　　因此要将这些值与它的parent（程序中的link）共享（不需要往下传，否则会TLE，因为只要下面的往上传过，不管怎样都能在上面取到max）。
　　我们可以沿着link一直往上跳，同时更新，然后就TLE了。
　　考虑按照拓扑序（状态加入的SAM顺序）DP，对于每个状态，只要更新一次就可以，其余的状态都可以递推得到。
　　由于STL用得太多，常数巨大，跑了200ms，但还是勉强进了VJudge的Leaderboard（Rank50），Rank49都只有80ms。
　　关掉I/O同步以后也跑了180ms。

#include<string>
#include<vector>
#include<iostream>
const int inf=0x7fffffff;
std::string s;
class SuffixAutomaton {
    private:
        static const int SIGMA_SIZE=26,N=10;
        struct State {
            State *link,*go[SIGMA_SIZE];
            int len,maxlen[N];
            State(const int l) {
                link=nullptr;
                std::fill(&go[0],&go[SIGMA_SIZE],nullptr);
                std::fill(&maxlen[0],&maxlen[N],0);
                maxlen[0]=inf;
                len=l;
            }
        };
        State *root,*last;
        int idx(const int ch) {
            return ch-'a';
        }
        std::vector<State*> v;
        void extend(const char ch) {
            const int w=idx(ch);
            State *p=last;
            State *new_p=new State(p->len+1);
            v.push_back(new_p);
            while(p!=nullptr&&p->go[w]==nullptr) {
                p->go[w]=new_p;
                p=p->link;
            }
            if(p==nullptr) {
                new_p->link=root;
            } else {
                State *q=p->go[w];
                if(q->len==p->len+1) {
                    new_p->link=q;
                } else {
                    State *new_q=new State(p->len+1);
                    v.push_back(new_q);
                    std::copy(&q->go[0],&q->go[SIGMA_SIZE],new_q->go);
                    new_q->link=q->link;
                    new_p->link=q->link=new_q;
                    while(p!=nullptr&&p->go[w]==q) {
                        p->go[w]=new_q;
                        p=p->link;
                    }
                }
            }
            last=new_p;
        }
    public:
        int cnt;
        void build(std::string &s) {
            root=last=new State(0);
            for(std::string::iterator i=s.begin();i<s.end();i++) extend(*i);
        }
        void match(std::string &s) {
            cnt++;
            State *p=root;
            int tmp=0;
            for(std::string::iterator i=s.begin();i<s.end();i++) {
                const int w=idx(*i);
                if(p->go[w]!=nullptr) {
                    p=p->go[w];
                    tmp++;
                } else {
                    while(p!=nullptr&&p->go[w]==nullptr) {
                        p=p->link;
                    }
                    if(p==nullptr) {
                        tmp=0;
                        p=root;
                    } else {
                        tmp=p->len+1;
                        p=p->go[w];
                    }
                }
                p->maxlen[cnt]=std::max(p->maxlen[cnt],tmp);
            }
            for(std::vector<State*>::iterator i=v.begin();i!=v.end();i++) {
                State *p=*i,*q=(*i)->link;
                if(q!=nullptr&&q->maxlen[cnt]!=p->maxlen[cnt]) {
                    q->maxlen[cnt]=std::max(q->maxlen[cnt],std::min(p->maxlen[cnt],q->len));
                }
            }
            for(std::vector<State*>::iterator i=v.begin();i!=v.end();i++) {
                State *p=*i;
                p->maxlen[0]=std::min(p->maxlen[0],p->maxlen[cnt]);
            }
        }
        int lcs() {
            int ret=0;
            for(std::vector<State*>::iterator i=v.begin();i!=v.end();i++) {
                State *p=*i;
                ret=std::max(ret,p->maxlen[0]);
            }
            return ret;
        }
};
SuffixAutomaton sam;
int main() {
    std::ios_base::sync_with_stdio(false);
    std::cin.tie(NULL); 
    std::cin>>s;
    sam.build(s);
    while(std::cin>>s) sam.match(s);
    std::cout<<sam.lcs()<<std::endl;
    return 0;
}