HDOJ 2222 Keywords Search

Accepted

2222

593MS

30816K

2430 B

G++

第一道 AC 自动机，理解了就好写；

需要注意字典可能重复，重复的不能按一次算。

# include <cstdio>
# include <cstring>
# include <queue>

using namespace std;

# define WORD_LEN 50 + 5
# define MAXN 10000 + 5
# define ALPHA_SIZE 26

int n, id;
char t[1000000 + 10];
char w[MAXN][WORD_LEN];

struct node
{
    node * fail;
    node * next[ALPHA_SIZE];
    int id;
    int isEnd;        // 字典里有重复的单词 
    node ()
    {
        fail = NULL;
        memset(next, 0, sizeof(next));
        id = 0;
        isEnd = 0;
    }
}* root;


int alpha_map(char ch)
{
    return ch - 'a';
}

void insert_trie(node * root, char *s)
{
    int c, i;
    node * p = root;
    for (i = 0; s[i]; ++i)
    {
        c = alpha_map(s[i]);
        if (NULL == p->next[c]) p->next[c] = new node;
        p = p->next[c];
    }
    ++(p->isEnd);
}

void build_trie(node * root)
{
    for (int i = 0; i < n; ++i)
        insert_trie(root, w[i]);
}

void build_AC_auto(node *root)
{
    int i;
    node *cur, *tmp;
    queue <node *> Q;

    // 根节点的子节点单独处理
    Q.push(root);
    for (i = 0; i < ALPHA_SIZE; ++i)
    {
        if (root->next[i])
        {
            root->next[i]->fail = root;
            Q.push(root->next[i]);
        }
    }Q.pop();    // 根节点出队

    // 更新非根节点子节点的 fail
    while (!Q.empty())
    {
        cur = Q.front(); Q.pop();    // 当前节点出队
        for (i = 0; i < ALPHA_SIZE; ++i)
        {
            if (cur->next[i])
            {
                tmp = cur->fail;            // 找到当前节点的 fail
                // 更新子节点的 fail
                while (tmp)
                {
                    if (tmp->next[i])
                    {
                        cur->next[i]->fail = tmp->next[i];
                        break;
                    }
                    tmp = tmp->fail;
                }
                // 没有找到可以匹配的
                if (NULL == tmp)
                {
                    cur->next[i]->fail = root;
                }
                // 将子节点入队
                Q.push(cur->next[i]);
            }
        }
    }
}

int search(char *t, node * root)
{
    int i, c, ret = 0;
    node *tmp, *p = root;

    for (i = 0; t[i]; ++i)
    {
        c = alpha_map(t[i]);
        while (root != p && NULL == p->next[c]) p = p->fail;
        p = p->next[c];
        if (NULL == p) p = root;
        tmp = p;
        while (tmp)
        {
            if (tmp->isEnd)
            {
                ret += tmp->isEnd;
                tmp->isEnd = 0;
            }
            tmp = tmp->fail;
        }
    }

    return ret;
}

void init(void)
{
    id = 0;
    scanf("%d", &n);
    for (int i = 0; i < n; ++i)
        scanf("%s", w[i]);
    scanf("%s", t);
}

void solve(void)
{
    root = new node;
    build_trie(root);
    build_AC_auto(root);
    printf("%d\n", search(t, root));
}

int main()
{
    int T;

    scanf("%d", &T);
    while (T--)
    {
        init();
        solve();
    }

    return 0;
}

/**/