HDU 3065 病毒侵袭持续中 AC自动机

HDU 3065

AC自动机 这个也可以拿来做模板了，使用静态数组模拟建树

//#pragma comment(linker, "/STACK:1677721600")
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <cmath>
#include <ctime>
#include <vector>
#include <cstdio>
#include <cctype>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>
using namespace std;
#define INF 0x3f3f3f3f
#define inf (-((LL)1<<40))
#define lson k<<1, L, (L + R)>>1
#define rson k<<1|1,  ((L + R)>>1) + 1, R
#define mem0(a) memset(a,0,sizeof(a))
#define mem1(a) memset(a,-1,sizeof(a))
#define mem(a, b) memset(a, b, sizeof(a))
#define FIN freopen("in.txt", "r", stdin)
#define FOUT freopen("out.txt", "w", stdout)
#define rep(i, a, b) for(int i = a; i <= b; i ++)
#define dec(i, a, b) for(int i = a; i >= b; i --)

template<class T> T MAX(T a, T b) { return a > b ? a : b; }
template<class T> T MIN(T a, T b) { return a < b ? a : b; }
template<class T> T GCD(T a, T b) { return b ? GCD(b, a%b) : a; }
template<class T> T LCM(T a, T b) { return a / GCD(a,b) * b;    }

//typedef __int64 LL;
typedef long long LL;
const int MAXN = 1000 + 100;
const int MAXM = 2000000 + 100;
const double eps = 1e-8;
LL MOD = 1000000007;


const int SIGMA_SIZE = 27;
const int MAX_LEN = 52;

struct ACMachine {
    int ch[MAXN * MAX_LEN][SIGMA_SIZE];
    int val[MAXN * MAX_LEN];
    int fail[MAXN * MAX_LEN];
    int last[MAXN * MAX_LEN];

    int id[MAXN * MAX_LEN], ans[MAXN];

    int node_cnt;
    queue<int>q;

    void init() {
        node_cnt = 0;
        mem0(ch); mem0(val);
        mem0(fail); mem0(last);
        while(!q.empty()) q.pop();
    }
    int get_idx(char ch) {
        if(ch >= 'A' && ch <= 'Z')
            return ch - 'A';
        return 26;
    }
    void insert_to_tree(char *str, int p) {
        int u = 0, len = strlen(str);
        rep (i, 0, len - 1) {
            int c = get_idx(str[i]);
            if(!ch[u][c]) {
                ch[u][c] = ++node_cnt;
            }
            u = ch[u][c];
        }
        val[u] ++;

        id[u] = p;
    }
    void get_fail() {
        rep (c, 0, SIGMA_SIZE - 1) {
            int u = ch[0][c];
            if(u) q.push(u);
        }
        while(!q.empty()) {
            int r = q.front(); q.pop();
            rep (c, 0, SIGMA_SIZE - 1) {
                int u = ch[r][c];
                if(!u) {
                    ch[r][c] = ch[fail[r]][c];
                    continue;
                }
                q.push(u);
                int v = fail[r];
                while(v && !ch[v][c]) v = fail[v];
                fail[u] = ch[v][c];
                last[u] = val[fail[u]] ? fail[u] : last[fail[u]];
            }
        }
    }
    void find_ans(char *str) {

        mem0(ans);

        int len = strlen(str), u = 0;
        rep(i, 0, len - 1) {
            int c = get_idx(str[i]);
            u = ch[u][c];
            int v = u;
            while(v) {
                if(val[v]) {
                    ans[id[u]] ++;
                }
                v = last[v];
            }
        }

    }
}acm;

int n;
char str[MAXM], s[MAXN][MAX_LEN];

int main()
{
//    FIN;
    while(~scanf("%d%*c", &n)) {
        acm.init();
        rep (i, 1, n) {
            scanf("%s", s[i]);
            acm.insert_to_tree(s[i], i);
        }
        acm.get_fail();
        scanf("%s", str);
        acm.find_ans(str);
        rep (i, 1, n) if(acm.ans[i]){
            printf("%s: %d
", s[i], acm.ans[i]);
        }
    }
    return 0;
}