[HDU5343]MZL's Circle Zhou

题目大意：
　　给你两个字符串a和b，从中分别取出子串x和y，求不同的x+y的个数。

思路：
　　对于每一个字符串，构建SAM。
　　为了保证相同的x+y不会被重复统计，我们可以想办法只统计相同的x+y中x最长的一种情况。
　　考虑在SAM上DP。
　　用DFS对a的SAM进行遍历，若当前遍历到的串x不能加上字符c时，在b的SAM中寻找以c开头的y，显然对于这样的x+y，x一定是最长的。
　　然后用G++交到HDU上发现TLE了。
　　觉得是自己DFS哪里死循环了，未果。
　　感觉是被卡常数，用C++交了一发，WA。
　　觉得自己的DP可能写的有问题，还是未果。
　　估算最后答案的范围，感觉会爆int，就改成了long long。
　　又交了一发还是WA。
　　随便找了一个题解看看，发现要用unsigned long long，然后就A了。
　　这时候再用G++交，不仅A了，而且跑得比C++还快。
　　结论：HDU的G++有毒！

#include<cstdio>
#include<cstring>
const int LEN=90001;
char s[LEN];
const int SIGMA_SIZE=26;
struct SuffixAutomaton {
    int idx(const char ch) {
        return ch-'a';
    }
    struct State {
        int link,go[SIGMA_SIZE],len;
    };
    State s[LEN<<1];
    int len;
    int sz,newState(const int l) {
        sz++;
        s[sz].len=l;
        return sz;
    }
    int root,last;
    void extend(const char ch) {
        const int w=idx(ch);
        int p=last,new_p=newState(s[last].len+1);
        while(p&&!s[p].go[w]) {
            s[p].go[w]=new_p;
            p=s[p].link;
        }
        if(!p) {
            s[new_p].link=root;
        } else {
            int q=s[p].go[w];
            if(s[q].len==s[p].len+1) {
                s[new_p].link=q;
            } else {
                int new_q=newState(s[p].len+1);
                memcpy(s[new_q].go,s[q].go,sizeof s[q].go);
                s[new_q].link=s[q].link;
                s[q].link=s[new_p].link=new_q;
                while(p&&s[p].go[w]==q) {
                    s[p].go[w]=new_q;
                    p=s[p].link;
                }
            }
        }
        last=new_p;
    }
    void build(char str[]) {
        len=strlen(str);
        sz=0;
        memset(s,0,sizeof s);
        root=last=newState(0);
        for(int i=0;str[i];i++) extend(str[i]);
    }
};
SuffixAutomaton sama,samb;
unsigned long long fa[LEN<<1],fb[LEN<<1];
unsigned long long dfsb(const int x) {
    if(~fb[x]) return fb[x];
    fb[x]=1;
    for(int i=0;i<SIGMA_SIZE;i++) {
        if(samb.s[x].go[i]) {
            fb[x]+=dfsb(samb.s[x].go[i]);
        }
    }
    return fb[x];
}
unsigned long long dfsa(const int x) {
    if(~fa[x]) return fa[x];
    fa[x]=1;
    for(int i=0;i<SIGMA_SIZE;i++) {
        if(sama.s[x].go[i]) {
            fa[x]+=dfsa(sama.s[x].go[i]);
        } else {
            if(samb.s[1].go[i]) {
                fa[x]+=dfsb(samb.s[1].go[i]);
            }
        }
    }
    return fa[x];
}
int main() {
    int T;
    scanf("%d",&T);
    while(T--) {
        scanf("%s",s);
        sama.build(s);
        scanf("%s",s);
        samb.build(s);
        memset(fa,-1,sizeof fa);
        memset(fb,-1,sizeof fb);
        printf("%llu
",dfsa(1));
    }
    return 0;
}