[SDOI2016]生成魔咒

OJ题号：
　　BZOJ4516

题目大意：
　　按顺序在一个序列的末尾插入数字，每次求出插入后能得到的本质不同的子串个数。

思路：
　　每次在SAM后加入这个数字，每次新出现的本质不同的子串个数就等于new_p->len-new_p->link->len。
　　由于数字范围比较大，可以考虑离散化或者map。
　　事实上也可以用hash，不过实践证明会比map还慢很多，内存也浪费很多。
　　另外需要注意开long long。

#include<map>
#include<cstdio>
#include<cctype>
inline int getint() {
    char ch;
    while(!isdigit(ch=getchar()));
    int x=ch^'0';
    while(isdigit(ch=getchar())) x=(((x<<2)+x)<<1)+(ch^'0');
    return x;
}
class SuffixAutomaton {
    private:
        struct State {
            State *link;
            std::map<int,State*> go;
            int len;
            State(const int l) {
                link=NULL;
                len=l;
            }
        };
        State *root,*last;
        long long ans;
        void extend(const int w) {
            State *p=last,*new_p=new State(last->len+1);
            while(p!=NULL&&!p->go.count(w)) {
                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);
                    new_q->go=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;
            ans+=new_p->len-new_p->link->len;
        }
    public:
        SuffixAutomaton() {
            root=last=new State(0);
        }
        long long query(const int w) {
            extend(w);
            return ans;
        }
};
SuffixAutomaton sam;
int main() {
    for(int n=getint();n;n--) printf("%lld\n",sam.query(getint()));
    return 0;
}

附hash_map和map的比较：