hdu5384（trie树）

hdu5384

给定n个字符串Ai

给定m个字符串Bi

问所有的Bi在每个Ai中出现了多少次

很显然，对Bi建Trie图，然后每次用Ai去匹配的时候，不断查找当前匹配串的最长后缀，这样就能找到答案了

比赛的时候也这样水过了。（又一次我认为这样不会过，但是交上去却过了）

如有有这样的数据的话

1

1 1

10^5个a

10^5个a

那么时间复杂度是10^10,

其实上面不断查找当前匹配串的最长后缀是没必要的，是重复操作的。

如果我们知道当前匹配串的最长后缀包含了多少个Bi，那么就不用去不断回溯了。

所以我们只要在构建fail指针的时候，处理处当前fail指针指向的字符串包含了多少个Bi，那么就不用不断的回溯了。

（哈哈，学到东西了）

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <algorithm>
#include <iostream>
#include <queue>
#include <stack>
#include <vector>
#include <map>
#include <set>
#include <string>
#include <math.h>
using namespace std;
#pragma warning(disable:4996)
#pragma comment(linker, "/STACK:1024000000,1024000000")
typedef long long LL;                   
const int INF = 1<<30;
/*

*/
const int N = 1000000 + 10;
struct Node
{
    int fail, next[26];
    int cnt;
    void init()
    {
        fail = -1;
        cnt = 0;
        for (int i = 0; i < 26; ++i)
            next[i] = -1;
    }
}Trie[N];
int size;
void insert(int root, char *str)
{
    int idx, cur = root;
    for (int i = 0; str[i]; ++i)
    {
        idx = str[i] - 'a';
        if (Trie[cur].next[idx] == -1)
        {
            Trie[size].init();
            Trie[cur].next[idx] = size++;
        }
        cur = Trie[cur].next[idx];
    }
    Trie[cur].cnt++;
}
void makeFail(int root)
{
    queue<int> q;
    for (int i = 0; i < 26; ++i)
    {
        if (Trie[root].next[i] == -1)
            Trie[root].next[i] = root;
        else
        {
            Trie[Trie[root].next[i]].fail = root;
            q.push(Trie[root].next[i]);
        }
    }
    while (!q.empty())
    {
        int cur = q.front();
        q.pop();
        for (int i = 0; i < 26; ++i)
        {
            if (Trie[cur].next[i] == -1)
            {
                Trie[cur].next[i] = Trie[Trie[cur].fail].next[i];
            }
            else
            {
                Trie[Trie[cur].next[i]].fail = Trie[Trie[cur].fail].next[i];
                //处理处，当前fail指针指向的字符串包含了多少个Bi
                Trie[Trie[cur].next[i]].cnt += Trie[Trie[Trie[cur].fail].next[i]].cnt;
                q.push(Trie[cur].next[i]);
            }

        }
    }
}
int match(int root, char *str)
{
    int i = 0;
    int idx;
    int cur = root;
    int ret = 0;
    while (str[i])
    {
        idx = str[i] - 'a';
        cur = Trie[cur].next[idx];
        //int tmp = cur;
        //while (tmp != root)
        //{
        //    ret += Trie[tmp].cnt;
        //    tmp = Trie[tmp].fail;
        //}
        
        ret += Trie[cur].cnt;
        i++;
    }
    return ret;
}
/*
题目问所有的Bi在每一个Ai中出现的次数

一个串的所有子串可以表示为它所有前缀的后缀
对所有的Bi建trie图
我们可以让每个Ai匹配的时候，就让这个当前字符串不断的去寻找最长后缀，
时间复杂度吵了
，然而数据水，居然过了
*/

char str[666666];
char str2[666666];
int main()
{
    int t, n, m;
    //freopen("d:/in.txt", "r", stdin);
    scanf("%d", &t);
    while (t--)
    {
        scanf("%d%d", &n, &m);
        int idx = 0;
        size = 1;
        Trie[0].init();
        Trie[0].fail = 0;
        for (int i = 0; i < n; ++i)
        {
            scanf("%s", str + idx);
            idx += strlen(str + idx) + 1;
        }
        for (int i = 0; i < m; ++i)
        {
            scanf("%s", str2);
            insert(0,str2);
        }
        makeFail(0);
        idx = 0;
        for (int i = 0; i < n; ++i)
        {
            printf("%d
", match(0, str + idx));
            idx += strlen(str + idx) + 1;
        }
    }
    return 0;
}