uva 1449 Dominating Patterns(ac自动机)

最基本的匹配，适合用来熟悉ac自动机。

KMP已经理解得差不多了，但是要完全理解ac自动机还有一定难度。

在打模板的时候，我发现把KMP的代码和ac的代码对照着看，找出KMP里的代码对应的是ac里的哪些代码，对提高理解蛮有用~~

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <vector>
#include <queue>
#include <stack>
#include <cassert>
#include <algorithm>
#include <cmath>
#include <limits>
#include <set>
#include <map>

using namespace std;

#define MIN(a, b) a < b ? a : b
#define MAX(a, b) a > b ? a : b
#define F(i, n) for (int i=0;i<(n);++i)
#define REP(i, s, t) for(int i=s;i<=t;++i)
#define UREP(i, s, t) for(int i=s;i>=t;--i)
#define REPOK(i, s, t, o) for(int i=s;i<=t && o;++i)
#define MEM0(addr, size) memset(addr, 0, size)
#define LBIT(x) x&-x

#define PI 3.1415926535897932384626433832795
#define HALF_PI 1.5707963267948966192313216916398
#define eps 1e-15

#define MAXN 1000000
#define MAXM 100
#define MOD 20071027

typedef long long LL;

const double maxdouble = numeric_limits<double>::max();
const int INF = 0x7FFFFFFF;

const int MAXS = 150;
const int CHARSET = 26, BASE = 'a', MAX_NODE = 30000;
struct AhoCorasicAutomata {
    int child[MAX_NODE + 1][CHARSET];
    int val[MAX_NODE + 1];
    int last[MAX_NODE+1];// fail函数里面为单词节点的子集
    int f[MAX_NODE + 1];// fail函数
    int cnt[MAXS + 1]; // 字符串出现次数
    map<string, int> ms; // 处理重复的模板
    int sz;
    AhoCorasicAutomata()
    {
        init();
    }
    void init()
    {
        sz = 1;
        memset(child[0], 0, sizeof(child[0]));
        memset(cnt, 0, sizeof(cnt));
        ms.clear();
    }
    int idx(char c) // 字符->index, 修改以适应不同字符集
    {
        return c - BASE;
    }
    void insert(const char *str, int v) // 插入一个单词
    {
        int u = 0;
        int len = strlen(str);
        int c;
        for (int i=0;i<len;++i) {
            c = idx(str[i]);
            if (!child[u][c]) {
                memset(child[sz], 0, sizeof(child[sz]));
                val[sz] = 0;
                child[u][c] = sz++;
            }
            u = child[u][c];
        }
        val[u] = v;
        ms[string(str)] = v;
    }
    void print(int j) {
        if (j) {
            cnt[val[j]]++;
            print(last[j]);
        }
    }

    int find(char* T) {
        int n = strlen(T);
        int j = 0;
        F(i, n) {
            int c = idx(T[i]);
            while(j && !child[j][c])
                j = f[j];
            j = child[j][c];
            if (val[j])
                print(j);
            else if (last[j])
                print(last[j]);
        }
    }
    void getFail() {
        queue<int> q;
        f[0] = 0;
        REP(c, 0, CHARSET-1) {
            int u = child[0][c];
            if (u) {
                f[u] = 0;
                q.push(u);
            }
        }
        //cout << "que size: " << q.size() << endl;
        while(!q.empty()) {
            int r = q.front();
            q.pop();
            F(c, CHARSET) {
                int u = child[r][c];
                if(!u)
                    continue;
                q.push(u);
                int v = f[r];
                while(v && !child[v][c])
                    v = f[v];
                f[u] = child[v][c]; // 和KMP中的f[i+1]=P[i]==P[j]?j+1:0一样
                last[u] = val[f[u]] ? f[u] : last[f[u]];
            }
        }
        //REP(i, 0, sz-1)
        //    printf("%d ", f[i]);
        //printf("\n");
    }
};

AhoCorasicAutomata ac;
char buf[MAXS + 1][MAXM + 1];
char text[MAXN + 1];
int main()
{
    freopen("input.in", "r", stdin);
    int n;
    int best;

    while(scanf("%d", &n) != EOF && n) {
        ac.init();
        F(i, n) {
            scanf("%s", buf[i]);
            ac.insert(buf[i], i+1);
        }
        scanf("%s", text);
        ac.getFail();
        ac.find(text);
        best = -INF;
        REP(i, 1, n)
            best = max(best, ac.cnt[i]);
        printf("%d\n", best);
        REP(i, 0, n-1) {
            int v = ac.ms[string(buf[i])];
            if ( ac.cnt[v] == best)
                printf("%s\n", buf[i]);
        }
    }
    return 0;
}