POJ 1204 AC自动机

链接：

http://poj.org/problem?id=1204

题意：

给定一个n*m的大写字母组成的矩阵，再给定C个单词，这些单词可能出现在矩阵中，出现的方向可能是上、下、左、右、左上、右上、左下、右下

问这C个单词的第一个字母出现在矩阵中的什么位置，以及出现的方向。

题解：

这题有两种解法，第一种是用字典树+深搜，用单词建立一颗字典树，然后八个方向去深搜，很容易想也很容易写，这种方法在数据很给力的的时候就会超时，所以不多讲。

第二种方法是AC自动机，在AC自动机题目中算比较常规的字符串匹配问题。

由于要记录每个单词单词在矩阵的第一个字母顺序和方向，这有些困难，因为在匹配的过程中初始没办法回溯求初始位置，硬要这样的话肯定也行，比较麻烦。

考虑将单词反转，这样就是最后匹配到的那个位置，这样就不要回溯。

建好字典树后改装成AC自动机，然后在矩阵中从12个方向去查询，如果遇到危险节点（某个单词在这里结束）就可以记录这个单词的位置和方向了。

这里并不需要记录12个方向的字符串，只要在查询的过程按照某个方向一直走就好。

代码：

int n, m, w;
string s[MAXN];
int pos[MAXN][3];
int dir[8][2] = { 0,1,0,-1,1,0,-1,0,1,1,-1,-1,1,-1,-1,1 };
char ch[9] = "CGEADHFB";
int head, tail;

struct node {
    node *fail;
    node *next[26];
    int id;
    node() {
        fail = NULL;
        id= 0;
        rep(i, 0, 26) next[i] = NULL;
    }
}*q[1000010];
node *root;

void insert(string s, int id) {
    node *p = root;
    int len = s.length();
    rep(i, 0, len) {
        int temp = s[i] - 'A';
        if (p->next[temp] == NULL) p->next[temp] = new node();
        p = p->next[temp];
    }
    p->id = id;
}

void build_ac() {
    q[tail++] = root;
    while (head != tail) {
        node *p = q[head++];
        node *temp = NULL;
        rep(i, 0, 26) if (p->next[i] != NULL) {
            if (p == root) p->next[i]->fail = root;
            else {
                temp = p->fail;
                while (temp != NULL) {
                    if (temp->next[i] != NULL) {
                        p->next[i]->fail = temp->next[i];
                        break;
                    }
                    temp = temp->fail;
                }
                if (temp == NULL) p->next[i]->fail = root;
            }
            q[tail++] = p->next[i];
        }
    }
}

void query(int x, int y, int d, int id) {
    node *p = root;
    while (x >= 0 && x < n && y >= 0 && y < m) {
        int index = s[x][y] - 'A';
        while (p->next[index] == NULL && p != root) p = p->fail;
        p = p->next[index];
        if (p == NULL) p = root;
        node *temp = p;
        while (temp != root && temp->id) {
            int k = temp->id;
            if (pos[k][0] > x || pos[k][0] == x && pos[k][1] > y)
                pos[k][0] = x, pos[k][1] = y, pos[k][2] = id;
            temp = temp->fail;
        }
        x += dir[d][0];
        y += dir[d][1];
    }
}

int main() {
    ios::sync_with_stdio(false), cin.tie(0);
    cin >> n >> m >> w;
    root = new node(); 
    rep(i, 0, n) cin >> s[i];
    rep(i, 1, w + 1) {
        string a;
        cin >> a;
        reverse(all(a));
        insert(a, i);
        pos[i][0] = pos[i][1] = INF;
    }
    build_ac();
    rep(i, 0, n) {
        query(i, 0, 0, 1), query(i, m - 1, 1, 0);
        query(i, 0, 7, 6), query(i, m - 1, 6, 7);
        query(i, 0, 4, 5), query(i, m - 1, 5, 4);
    }
    rep(i, 0, m) {
        query(0, i, 2, 3), query(n - 1, i, 3, 2);
        query(0, i, 6, 7), query(n - 1, i, 7, 6);
        query(0, i, 4, 5), query(n - 1, i, 5, 4);
    }
    rep(i, 1, w + 1)
        cout << pos[i][0] << ' ' << pos[i][1] << ' ' << ch[pos[i][2]] << endl;
    return 0;
}