[SPOJ-LCS]Longest Common Substring

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

思路：
　　对其中一个字符串构建SAM，然后用另一个字符串在里面匹配，按照SAM的边一直往下走，匹配到的连续的字符数就是公共字串的长度。

#include<string>
#include<cstring>
#include<iostream>
std::string s,t;
class SuffixAutomaton {
    private:
        static const int SIGMA_SIZE=26;
        int idx(const char ch) {
            return ch-'a';
        }
        struct State {
            State *link,*go[SIGMA_SIZE];
            int len;
            State(const int l) {
                link=NULL;
                len=l;
                memset(go,0,sizeof go);
            }
        };
        State *root,*last;
        void extend(const char ch) {
            int w=idx(ch);
            State *p=last;
            State *new_p=new State(p->len+1);
            while(p!=NULL&&p->go[w]==NULL) {
                p->go[w]=new_p;
                p=p->link;
            }
            if(p==NULL) {
                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);
                    memcpy(new_q->go,q->go,sizeof q->go);
                    new_q->link=q->link;
                    q->link=new_p->link=new_q;
                    while(p!=NULL&&p->go[w]==q) {
                        p->go[w]=new_q;
                        p=p->link;
                    }
                }
            }
            last=new_p;
        }
    public:
        void build(std::string &s) {
            last=root=new State(0);
            for(std::string::iterator i=s.begin();i<s.end();i++) extend(*i);
        }
        int match(std::string &s) {
            int ret=0,tmp=0;
            State *p=root;
            for(std::string::iterator i=s.begin();i<s.end();i++) {
                int w=idx(*i);
                if(p!=NULL&&p->go[w]!=NULL) {
                    p=p->go[w];
                    tmp++;
                } else {
                    while(p!=NULL&&p->go[w]==NULL) p=p->link;
                    if(p==NULL) {
                        p=root;
                        tmp=0;
                    } else {
                        tmp=p->len+1;
                        p=p->go[w];
                    }
                }
                ret=std::max(ret,tmp);
            }
            return ret;
        }
};
SuffixAutomaton sam;
int main() {
    std::ios_base::sync_with_stdio(false);
    std::cin.tie(NULL);
    std::cin>>s;
    sam.build(s);
    std::cin>>s;
    std::cout<<sam.match(s)<<std::endl;
    return 0;
}