Match:Keywords Search(AC自动机模板)(HDU 2222)

　　　　　　　　　　　　　　　　

　　　　　　　　　　　　　　　　　　多模匹配

　　题目大意：给定很多个字串A，B，C，D，E....，然后再给你目标串str字串，看目标串中出现多少个给定的字串。

　　经典AC自动机模板题，不多说。

　　

#include <iostream>
#include <algorithm>
#include <functional>
#include <string.h>
#define MAX 26

using namespace std;

struct node
{
    node *fail, *next[MAX];
    int count;
}Mem_Pool[500001], *Trie_Queue[500001];
static int Used_Node;
static char pattern[10001], target[1000001];

struct node *Get_New_Node(void);
void Insert(struct node*);
void Build_AC_Automation(struct node* const);
static int Query(struct node* const);

int main(void)
{
    int case_sum, pattern_sum;
    scanf("%d", &case_sum);
    
    while (case_sum--)
    {
        Used_Node = 0;
        node *root = Get_New_Node();//每一次都拿一个新的根
        scanf("%d", &pattern_sum);
        getchar();
        while (pattern_sum--)
            Insert(root);
        Build_AC_Automation(root);
        gets(target);
        printf("%d
", Query(root));
    }
}

struct node *Get_New_Node(void)
{
    Mem_Pool[Used_Node].count = 0;
    Mem_Pool[Used_Node].fail = NULL;
    memset(Mem_Pool[Used_Node].next, 0, sizeof(struct node *)*MAX);

    return &Mem_Pool[Used_Node++];
}

void Insert(struct node *root)
{
    gets(pattern);

    node *p = root;
    int index;
    for (int i = 0; pattern[i] != ''; i++)
    {
        index = pattern[i] - 'a';
        if (p->next[index] == NULL)
            p->next[index] = Get_New_Node();
        p = p->next[index];
    }
    p->count++;//表示这个位置包含着一个字符，如果有多个则叠加就可以了。
}

void Build_AC_Automation(struct node *const root)//自动机的构造例程，其实就是个BFS
{
    root->fail = NULL;
    int head = 0, back = 0;
    node *out = NULL, *tmp = NULL;
    Trie_Queue[back++] = root;

    while (head != back)
    {
        out = Trie_Queue[head++];
        for (int i = 0; i < MAX; i++)//枚举所有情况
            if (out->next[i] != NULL)
            {
                if (out == root)
                    out->next[i]->fail = root;//如果out自己就是根，那么直接将其子节点的失败指针指向自己就好了
                else
                {
                    for (tmp = out->fail; tmp != NULL; tmp = tmp->fail)
                        if (tmp->next[i] != NULL)
                        {
                            out->next[i]->fail = tmp->next[i];
                            //如果还找到在其他地方找到和他一样的元素，那么我们就把失败指针指向这个元素
                            break;
                        }
                    if (tmp == NULL)
                        out->next[i]->fail = root;
                }
                Trie_Queue[back++] = out->next[i];
            }
    }
}

static int Query(struct node *const root)
{
    int ans = 0;
    node *tmp = root, *other = NULL;
    //tmp是跟着目标串的移动而移动的，other指针则表示在tire树的其他位置看还能不能匹配到其他字串
    for (int i = 0; target[i] != ''; i++)
    {
        int index = target[i] - 'a';
        while (tmp->next[index] == NULL && tmp != root)
            tmp = tmp->fail;//沿着失败指针一直走
        tmp = tmp->next[index];
        tmp = (tmp == NULL) ? root : tmp;//检查如果是已经是root了，直接跳出来就好了
        for (other = tmp; other != root && other->count != -1; other = other->fail)
        {
            ans += other->count;
            other->count = -1;//标记一下，不要重复扫描
        }
    }
    return ans;
}