字典树 kmp ac自动机

讲一个简单的例子

ababcbababacba 里面是否包含 bababac

根据我记得最裸的写法是 O(nm)的bf算法 。就是逐个匹配，但是时间非常的浪费。所以有了这kmp。

kmp 是针对 模式串 进行预处理过 来达到速度提升。

 a bab c bababacba 

    bab a bac  

此时我们匹配到了这一步发现 a c 并不匹配，于是进入下个一个匹配 而如果我们知道 a 失配了 就会跳到 上次与之前相配的前缀去 变成了

 aba bc  bababacba 

        ba  babac  

我们可以观察一下bababac ,如果有一个字符串 和 他 匹配到 baba 了 那么代表了 当前下一个字符是 a 是不匹配的 而接下来的 是 ba 是可以匹配的 

 ababc baba bacba 

            baba bac      

那么最好的策略是从跳到下个配点去的，这样子就能节省时间。

而我们会建立一个next[]的数组 他的每一位（个人理解）是指向之前和他相邻 最长的与模式字符串前缀（不包含自己）相等的长度。

#define Max 100010
int next[Max]; //预处理数组

void kmp(char *s)
{
    next[0]=-1;
    int i=0,j=-1;
    while(s[i])
    {
        if(j==-1||s[i]==s[j])
        {
            i++;
            j++;
            next[i]=j;
        }
        else
            j=next[j];
    }
}//自我匹配


bool Match(char *s1,char *s2)
{
    int i=0,j=-1;
    while(s1[i])
    {
        if(j==-1||s1[i]==s2[j])
        {
            i++;
            j++;
        }
        else
            j=next[j]; //回溯上次最佳位置


        if(s2[j]=='\0')
            return true; //匹配成功
    }
    return false;
}

接下来是字典树，我感觉比较简单，所以我打算写少一点。

根据字典树，我们可以很快的查找一些字符串。

假设我们 要查一个单词，我必须根据每一个字母的前一个字母逐步下向下查找。字典树也是一样道理，首先我们建立一棵树，从一个 根节点，根据字符串，我们开始向下遍历就可以了。

struct node
{
    node *next[26];
    int val;
    node()
    {
        val=0;
        memset(next,0,sizeof(next));
    }
}; //节点


void build(node,*root,char *s)
{
    node *p=root;
    for(int i=0;s[i];i++)
    {
        int t=s[i]-'a';
        if(p->next[t]==NULL)p->next[t]=new node();
        p=p->next[t];
    }
    p->val++;
}//建树


bool node_search(node *root,char *s)
{
    node *p=root;
    for(int i=0;s[i];i++)
    {
        int t=s[i]-'a';
        if(p->next[t]==NULL) return false;
        p=p->next[t];
    }
    if(p->val==0)
        return false;
    return true;
}//查找

ac自动机 我第一次接触是为了 解决某一类问题的 即一个字符串中有包含了多少的模式串，即解决多串匹配问题。

同样我们 要构造一颗字典树。不过这颗字典树与一般的不同，他需要包含一个fail的指针。而这个指针有何用处呢？这也是ac自动机的精妙之处。fail指针，当时对于我通俗的来说是一个字符串的位置上 指向某一个字符串上的一个位置，而这个位置到自身根节点（即这个字符串的前缀）是与当前节点之前的某一段是匹配的。这样我们就能知道字符串之间的匹配和相容的程度。

接下来这张图片是网上通用的解释

接下来，就开始实现代码构造。

首先，我们如同建造一颗字典树一样，快速地建造一颗树，然后，我们开始从根节点开始用bfs开始搜索，每一个节点的上级节点如果与其他的节点有所匹配，可以从fail指针得知，便去查看是否有与其匹配的下级节点是否有与他相匹配的，若是没有那便是继续指向fail 的 fail 指针去探查下一个，直到根节点为止。构造之后我们就可以通过fail指针得知是否有与之相匹配的。

struct node
{
    node *fail;
    node *next[26];
    int num;
    int index;
};

node data[125];

node* newNode()
{
    memset(data[cnt].next,0,sizeof(data[cnt].next));
    data[cnt].fail=NULL;
    data[cnt].num=0;
    data[cnt].index=cnt;
    return &data[cnt++];
}

void insertT(node *root,char *s)
{
    node *p=root;
    for(int i=0;s[i];i++)
    {
        int t=s[i]-'a';
        if(p->next[t]==NULL)
            p->next[t]=newNode();
        p=p->next[t];
    }
    p->num=1;
}

void build_Ac(node *root)
{
    queue<node *> q;
    node *p = root;
    root->fail=root;
    q.push(root);
    while(!q.empty())
    {
        node *temp=q.front();
        q.pop();
        for(int i=0;i<26;i++)
        {
            if(temp->next[i]==NULL)
            {
                if(temp==root)
                    temp->next[i]=root;
                else
                    temp->next[i]=temp->fail->next[i];
            }
            else
            {
                q.push(temp->next[i]);
                if(temp==root)
                    temp->next[i]->fail=root;
                else
                {
                    p=temp->fail;
                    temp->next[i]->fail=p->next[i];
                }
            }
        }
    }
}