HDU 2222 Keywords Search(ac自动机模板)

Keywords Search

Problem Description

In the modern time, Search engine came into the life of everybody like Google, Baidu, etc.
Wiskey also wants to bring this feature to his image retrieval system.
Every image have a long description, when users type some keywords to find the image, the system will match the keywords with description of image and show the image which the most keywords be matched.
To simplify the problem, giving you a description of image, and some keywords, you should tell me how many keywords will be match.

 

Input

First line will contain one integer means how many cases will follow by.
Each case will contain two integers N means the number of keywords and N keywords follow. (N <= 10000)
Each keyword will only contains characters 'a'-'z', and the length will be not longer than 50.
The last line is the description, and the length will be not longer than 1000000.

 

Output

Print how many keywords are contained in the description.

 

Sample Input

1

5

she

he

say

shr

her

yasherhs

 

Sample Output

3

 以前总以为字符串很难学就一直没认真去学，遇见字符串的题，大部分都果断放弃了，哇现在看来真的是后悔。只要认真，学的还是挺快的

思路：ac自动机的模板题啦，找了很多大神的博客讲解ac自动机，终于算是弄懂一点点了吧，还是直接附上代码吧，都是套模板的题

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<string>
#include<queue>
using namespace std;
struct node {
    int data;
    node *fail;
    node *next[26];
    node() {
        data = 0; fail = NULL;
        memset(next, 0, sizeof(next));
    }
};
node* Insert(node *root, string str)
{
    node *p = root;
    int len = str.length();
    for (int i = 0; str[i]; i++) {
        int x = str[i] - 'a';
        if (p->next[x] == NULL)
            p->next[x] = new node;
        p = p->next[x];
    }
    p->data++;
    return root;
}
void build_ac(node *root)
{
    node *p, *tmp;
    queue<node*>Q;
    Q.push(root);
    while (!Q.empty()){
        p = Q.front(); Q.pop();
        for (int i = 0; i < 26; i++) {
            if (p->next[i] != NULL) {
                if (p == root)
                    p->next[i]->fail = root;
                else {
                    tmp = p->fail;
                    while (tmp) {
                        if (tmp->next[i]) {
                            p->next[i]->fail = tmp->next[i];
                            break;
                        }
                        tmp = tmp->fail;
                    }
                    if (tmp == NULL)p->next[i]->fail = root;
                }
                Q.push(p->next[i]);
            }
        }
    }
}
int ac(node *root, string str)
{
    int ans = 0, len = str.length();
    node *p = root, *tmp;
    for (int i = 0; i < len; i++) {
        while (p->next[str[i] - 'a'] == NULL && p != root)p = p->fail;
        p = p->next[str[i] - 'a'];
        if (p == NULL)p = root;
        tmp = p;
        while (tmp != root && tmp->data != -1) {
            ans += tmp->data;
            tmp->data = -1;
            tmp = tmp->fail;
        }
    }
    return ans;
}
int main()
{
    ios::sync_with_stdio(false);
    int t, n;
    cin >> t;
    while (t--) {
        cin >> n;
        string s; node *root = new node;
        for (int i = 0; i < n; i++) {
            cin >> s;
            Insert(root, s);
        }
        build_ac(root);
        cin >> s;
        cout << ac(root, s) << endl;
    }
    return 0;
}

有时候对空间要求比较高的时候用链表会爆空间，可能就需要使用静态数组来代替指针，也可以根据题目要求来限制插入字典树的单词个数来降低空间复杂度例如 HDU 1671

#include<iostream>
#include<algorithm>
#include<cstring>
#include<string>
#include<queue>

using namespace std;
const int maxn = 1000010;
const int max_tot = 500010;
const int max_size = 26;
char s[maxn], t[100];
struct AC {
    int trie[max_tot][max_size];
    int val[max_tot];
    int fail[max_tot], last[max_tot];
    int size;
    void Clear()
    {
        memset(trie[0], 0, sizeof(trie[0]));
        size = 1;
    }
    int idx(char x) { return x - 'a'; }
    void insert(char *str) {
        int k = 0;
        for (int i = 0; str[i]; i++) {
            int x = idx(str[i]);
            if (!trie[k][x]) {
                memset(trie[size], 0, sizeof(trie[size]));
                val[size] = 0;
                trie[k][x] = size++;
            }
            k = trie[k][x];
        }
        val[k]++;
    }
    void GetFail()
    {
        queue<int>Q;
        fail[0] = 0; int k = 0;
        for (int i = 0; i < max_size; i++) {//计算第一层的fail指针跟last指针
            k = trie[0][i];
            if (k) {
                Q.push(k);
                fail[k] = 0;
                last[k] = 0;
            }
        }
        while (!Q.empty()) {
            int r = Q.front(); Q.pop();
            for (int i = 0; i < max_size; i++) {
                k = trie[r][i];
                if (!k) {
                    trie[r][i] = trie[fail[r]][i];
                    continue;
                }
                Q.push(k);
                int v = fail[r];
                while (v && !trie[v][i])v = fail[k];
                fail[k] = trie[v][i];
                last[k] = (val[fail[k]] ? fail[k] : last[fail[k]]);
            }
        }
    }
    int Find(char *str) {
        int k = 0, cnt = 0;
        for (int i = 0; str[i]; i++) {
            int x = idx(str[i]);
            k = trie[k][x];
            int tmp = 0;
            if (val[k])tmp = k;
            else if (last[k])tmp = last[k];
            while (tmp) {
                cnt += val[tmp];
                val[tmp] = 0;
                tmp = last[tmp];
            }
        }
        return cnt;
    }
}ac;
int main()
{
    ios::sync_with_stdio(false);
    int t, n;
    cin >> t;
    while (t--) {
        cin >> n;
        ac.Clear();
        for (int i = 1; i <= n; i++) {
            cin >> s;
            ac.insert(s);
        }
        ac.GetFail();
        cin >> s;
        cout << ac.Find(s) << endl;
    }
    return 0;
}