后缀树(O(N))

#include <iostream>
#include <cstring>
using namespace std;

struct Edge
{
    int l, r, len;
}edge[400000];

struct Node
{
    Node *node[28];
    Edge *edge[28];
    bool info;
    int activeLength;
    Node *suffixLink;
    Node *parent;
    int num;

}node[400000], *st;

char strTemp[200008], pattern[200008];

class SuffixTree
{
public:
    int nodeNum, edgeNum;
    Node roots;
    Node* activeNode;
    Node* addNode;
    int minDistance, lastBound;
    int n;
    char *str;
    int maping[128]; 

    SuffixTree()
    {
        nodeNum=edgeNum=minDistance=lastBound=0;
        memset(roots.node, NULL, sizeof(roots.node));

        roots.info=false;
        roots.suffixLink=&roots;
        roots.activeLength=0;
        roots.num=-1;
        roots.parent=NULL;
        activeNode=&roots;
        addNode=NULL;

        for(int i=0; i<128; i++)
            maping[i]=26;
        for(int i='a'; i<='z'; i++)
            maping[i]=i-'a';
        maping['#']=27;
    }

    void create(char *s, int l)
    {
        str=s;
        n=l;
        Node *help;   
        for(int i=0; i<n; i++)
        {
            activeNode=activeNode->suffixLink;
            int start=i + activeNode->activeLength;
            int minDistanceTemp=lastBound - activeNode->activeLength - i;
            if(minDistanceTemp<0)
                minDistanceTemp=0;

            int t=maping[str[start]];

            while(activeNode->node[t] != NULL && 
                minDistanceTemp >= activeNode->edge[t]->len)
            {
                start=start + activeNode->edge[t]->len;
                minDistanceTemp=minDistanceTemp - activeNode->edge[t]->len;
                activeNode=activeNode->node[t];
                t=maping[str[start]];
            }
            //沿边一个一个字符进行比较
            help=activeNode;
            bool flag=false;
            int minDis=minDistanceTemp;

            while(activeNode->node[t]!=NULL)
            {
                int record=maping[str[start]];
                start += minDis;
                int l=help->edge[record]->l;
                int r=help->edge[record]->r;

                for(int j=l+minDis; j<=r; j++, start++)
                {
                    minDis=0;
                    if(str[j]!=str[start])
                    {
                        memset(node[nodeNum].node, NULL, sizeof(node[nodeNum].node));

                        node[nodeNum].info=false;
                        node[nodeNum].activeLength = activeNode->activeLength + (j-l);
                        node[nodeNum].num = nodeNum;
                       
                        flag=true;
       
                        help->edge[t]->r = j-1;
                        help->edge[t]->len=j - help->edge[t]->l;

                        int tt=maping[str[j]];

                        node[nodeNum].edge[tt]=&edge[edgeNum];
                        edge[edgeNum].l=j;
                        edge[edgeNum].r=r;
                        edge[edgeNum].len=r-j+1;

                        node[nodeNum].node[tt]=help->node[t];
                        help->node[t]->parent=&node[nodeNum];

                        help->node[t]=&node[nodeNum];
                        node[nodeNum].parent = help;

                        help=&node[nodeNum];

                        ++edgeNum;
                        ++nodeNum;

                        goto ans;
                    }   
                }
                activeNode=activeNode->node[t];
                help=activeNode;
                t=maping[str[start]];
            }
            ans:;
            //增加新的信息节点
            lastBound=start;

            Node *stmp=help;
            if(addNode!=NULL)
            {
                while(stmp->activeLength != addNode->activeLength-1)
                    stmp=stmp->parent;
                addNode->suffixLink=stmp;
            }

            if(flag)
                addNode=help;
            else
                addNode=NULL;

            if(addNode!=NULL && addNode->activeLength == 1)
            {
                addNode->suffixLink=&roots;
                addNode=NULL;
               
            }

            t=maping[str[start]];
            memset(node[nodeNum].node, NULL, sizeof(node[nodeNum].node));
            help->node[t]=&node[nodeNum];
            help->edge[t]=&edge[edgeNum];
            edge[edgeNum].l=start;
            edge[edgeNum].r=n-1;
            edge[edgeNum].len=n-start;

            node[nodeNum].info=true;
            node[nodeNum].num=nodeNum;
            ++nodeNum;
            ++edgeNum;
        }
    }

    bool search(char *pattern)
    {
        int length=strlen(pattern), patLen=0;
        Node *root=&roots;
        while(true)
        {
            int temp=maping[pattern[patLen++]];
            if(root->node[temp]==NULL)
                return false;
            if(patLen==length)
                return true;
            int l=root->edge[temp]->l+1, r=root->edge[temp]->r;
            for(int i=l; i<=r; i++)
            {
                if(str[i]!=pattern[patLen++])
                    return false;
                if(patLen==length)
                    return true;
            }
            root=root->node[temp];
        }
    }


    void dfs(Node *st, int l)
    {
        if(st->info)
        {
            printf("/n");
            return;
        }
        printf("它的儿子节点如下:/n");
        l=l+4;
        for(int i=0; i<28; i++)
        {
            if(st->node[i])
            {
                for(int j=0; j<l; j++)
                    printf(" ");
                printf("%d  ", st->edge[i]->l+1);
                for(int j=st->edge[i]->l; j<=st->edge[i]->r; j++)
                    printf("%c", strTemp[j]);
                dfs(st->node[i], l+st->edge[i]->len);

            }
        }
    }

    ~SuffixTree()
    {
        nodeNum=edgeNum=minDistance=lastBound=0;
        memset(roots.node, NULL, sizeof(roots.node));
        roots.info=false;
        roots.suffixLink=&roots;
        roots.activeLength=0;
    }
}suffixTree;

int main()
{
    printf("请输入字符串(只支持小写字母):");
    scanf("%s", &strTemp);
    int l=strlen(strTemp);
    strTemp[l++]='#';
    strTemp[l]='/0';
    suffixTree.create(strTemp, l);
    st=&suffixTree.roots;
    suffixTree.dfs(st, 0);
    printf("请输入模式串(输入EOF结束):");
    while(scanf("%s", &pattern)!=EOF)
    {
        bool ret=suffixTree.search(pattern);
        if(ret)
            printf("%s 是其子串/n", pattern);
        else
            printf("%s 不是其子串/n", pattern);
        printf("请输入模式串(输入EOF结束):");
    }
    return 0;
}