【小结】AC自动机

最新推荐文章于 2024-07-15 14:17:58 发布
最新推荐文章于 2024-07-15 14:17:58 发布
阅读量698 收藏
点赞数
分类专栏： 字符串 AC自动机
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bit_Line/article/details/47699647
版权
从 DFA 到 AC 自动机:
  • 考虑以下单词: {she, he, her} ，字母表 ∑ 为 26 个小写字母

  • 我们先画出它Trie树的模样
    Trie

  • 注意，双圈的是包含单词结尾的位置。然后我们尝试将它稍加改造，变成一个 DFA ！

  • 对每一个状态，必须补充下一个字母为其它（比如从起始状态出发，输入一个 h ，匹配上了，接下来输入可能为a∼z，我们已经有了 e 的箭头，还要补上其它的）。这里是补上根节点和从根走sh的那个后的结果：
    DFA1
  • 注意正则表达式 [∧sh] 表示除 s,h 外所有字母。我们考虑下面那个 sh 对应的状态，遇到 s 转到它的父节点，遇到h转到右边那个节点，遇到 e 到下面一个状态，遇到其它则直接转回起始状态。补充完余下的转移，完成后就可以拿来用了。比如我们拿到一个字符串，就可以想象自己就是这台DFA，每次读入一个字符，按照箭头的指示转至不同的状态，只要遇到了一个接受状态（图中双圈），就认为匹配上一次。我们发现，这台自动机已经可以完成我们要求的多模式匹配的任务了！也即通过对一堆串构造 DFA ，以后拿到一个串 M ，只需要每次读一个字符，然后走箭头，就可以完成M和这一大堆串的匹配～那么单次匹配的复杂度就只有 O(|M|) 了，这是线性的！
  • 下面，稍加转化，就可以将上述 DFA 变成 AC 自动机。依然考虑左边这个 sh 对应的状态，如果遇到 e ，转到下面一个转态，不需要改变；但是如果遇到了s和 h ，我们并不是直接按照s和 h 的指示完成转换然后继续后面的匹配，而是保留这个s或者 h ，先转到起始状态，然后再重新读入s或者 h 继续匹配。也就是说，只要发生了“失配”，就转到另一个状态，继续处理。这么做的好处是容易在代码上实现。于是sh对应状态在遇到 s 或者h时，也会转向起始状态，这个转向就时 AC 自动机的所谓 fail 指针。在匹配时，用一个 tmp 指针模拟我们的手指，开始时指向起始状态，遇到 s ，就按照s箭头的指示移动到对应状态，直到所有字符都读完，匹配结束。
  • 留个板子
/* **********************************************

  File Name: ac_automata.cpp

  Auther: zhengdongjian@tju.edu.cn

  Created Time: 2015年08月14日 星期五 08时41分23秒

*********************************************** */
#include <bits/stdc++.h>
using namespace std;

typedef pair<int, int> P;
const double EPS = 1e-8;
const double PI = acos(-1.0);

const int MAX = 500007;
const int MAXD = 26; //26 alphas
struct Trie {
    /* 
     * nxt & end is used in trie
     * fail is for ac automata
     */
    int nxt[MAX][MAXD], fail[MAX], end[MAX];
    int root, L; //root node, length(the nodes has been malloc)[0, L]
    int newnode() {
        memset(nxt[L], -1, sizeof(int) * MAXD);
        end[L++] = 0;
        return L - 1;
    }
    void clear() {
        L = 0;
        root = newnode();
    }
    void insert(char* buf) {
        int len = strlen(buf);
        int now = root;
        for (int i = 0; i < len; ++i) {
            if (nxt[now][buf[i] - 'a'] == -1) {
                nxt[now][buf[i] - 'a'] = newnode();
            }
            now = nxt[now][buf[i] - 'a'];
        }
        ++end[now];
    }
    void build() {
        queue<int> Q;
        fail[root] = root;
        for (int i = 0; i < MAXD; ++i) {
            if (nxt[root][i] == -1) {
                nxt[root][i] = root;
            } else {
                fail[nxt[root][i]] = root;
                Q.push(nxt[root][i]);
            }
        }

        while (!Q.empty()) {
            int now = Q.front();
            Q.pop();

            for (int i = 0; i < MAXD; ++i) {
                if (nxt[now][i] == -1) {
                    nxt[now][i] = nxt[fail[now]][i];
                } else {
                    fail[nxt[now][i]] = nxt[fail[now]][i];
                    Q.push(nxt[now][i]);
                }
            }
        }
    }
    int query(char* buf, int len = -1) {
        if (len == -1) {
            len = strlen(buf);
        }
        int now = root;
        int res = 0;
        for (int i = 0; i < len; ++i) {
            now = nxt[now][buf[i] - 'a'];
            int tmp = now;
            while (tmp != root) {
                res += end[tmp];
                end[tmp] = 0; //不重复，若可重复此处不置0即可
                tmp = fail[tmp];
            }
        }
        return res;
    }
    void debug() {
        for (int i = 0; i < L; ++i) {
            printf("%d, %d, %d, [%d", i, fail[i], end[i], nxt[i][0]);
            for (int j = 1; j < MAXD; ++j) {
                printf(" %d", nxt[i][j]);
            }
            puts("]");
        }
    }
} ac;

const int MAXL = 64;
char str[MAXL];
char buf[MAX << 1];

int main() {
    int T;
    scanf(" %d", &T);
    while (T--) {
        int n;
        scanf(" %d", &n);
        ac.clear();
        for (int i = 0; i < n; ++i) {
            scanf(" %s", str);
            ac.insert(str);
        }
        ac.build();

        scanf(" %s", buf);
        printf("%d\n", ac.query(buf));
    }
    return 0;
}

几个简单的小题目

  • hdu2222，First attempt
/* **********************************************

  File Name: ac_automata.cpp => hdu2222

  Auther: zhengdongjian@tju.edu.cn

  Created Time: 2015年08月14日 星期五 08时41分23秒

*********************************************** */
#include <bits/stdc++.h>
using namespace std;

typedef pair<int, int> P;
const double EPS = 1e-8;
const double PI = acos(-1.0);

const int MAX = 500007;
const int MAXD = 26; //26 alphas
struct Trie {
    /* 
     * nxt & end is used in trie
     * fail is for ac automata
     */
    int nxt[MAX][MAXD], fail[MAX], end[MAX];
    int root, L; //root node, length(the nodes has been malloc)[0, L]
    int newnode() {
        memset(nxt[L], -1, sizeof(int) * MAXD);
        end[L++] = 0;
        return L - 1;
    }
    void clear() {
        L = 0;
        root = newnode();
    }
    void insert(char* buf) {
        int len = strlen(buf);
        int now = root;
        for (int i = 0; i < len; ++i) {
            if (nxt[now][buf[i] - 'a'] == -1) {
                nxt[now][buf[i] - 'a'] = newnode();
            }
            now = nxt[now][buf[i] - 'a'];
        }
        ++end[now];
    }
    void build() {
        queue<int> Q;
        fail[root] = root;
        for (int i = 0; i < MAXD; ++i) {
            if (nxt[root][i] == -1) {
                nxt[root][i] = root;
            } else {
                fail[nxt[root][i]] = root;
                Q.push(nxt[root][i]);
            }
        }

        while (!Q.empty()) {
            int now = Q.front();
            Q.pop();

            for (int i = 0; i < MAXD; ++i) {
                if (nxt[now][i] == -1) {
                    nxt[now][i] = nxt[fail[now]][i];
                } else {
                    fail[nxt[now][i]] = nxt[fail[now]][i];
                    Q.push(nxt[now][i]);
                }
            }
        }
    }
    int query(char* buf, int len = -1) {
        if (len == -1) {
            len = strlen(buf);
        }
        int now = root;
        int res = 0;
        for (int i = 0; i < len; ++i) {
            now = nxt[now][buf[i] - 'a'];
            int tmp = now;
            while (tmp != root) {
                res += end[tmp];
                end[tmp] = 0; //不重复，若可重复此处不置0即可
                tmp = fail[tmp];
            }
        }
        return res;
    }
    void debug() {
        for (int i = 0; i < L; ++i) {
            printf("%d, %d, %d, [%d", i, fail[i], end[i], nxt[i][0]);
            for (int j = 1; j < MAXD; ++j) {
                printf(" %d", nxt[i][j]);
            }
            puts("]");
        }
    }
} ac;

const int MAXL = 64;
char str[MAXL];
char buf[MAX << 1];

int main() {
    int T;
    scanf(" %d", &T);
    while (T--) {
        int n;
        scanf(" %d", &n);
        ac.clear();
        for (int i = 0; i < n; ++i) {
            scanf(" %s", str);
            ac.insert(str);
        }
        ac.build();

        scanf(" %s", buf);
        printf("%d\n", ac.query(buf));
    }
    return 0;
}
  • hdu2896
  • 病毒保证不同，简单统计，随便搞
/* **********************************************

  File Name: 2896.cpp

  Auther: zhengdongjian@tju.edu.cn

  Created Time: 2015年08月14日 星期五 11时25分51秒

*********************************************** */
#include <bits/stdc++.h>
using namespace std;

typedef pair<int, int> P;
const double EPS = 1e-8;
const double PI = acos(-1.0);
const int MAX = 100007;
const int MAXD = 128;
struct Trie {
    int nxt[MAX][MAXD], fail[MAX], end[MAX];
    int root, L;

    int newnode() {
        memset(nxt[L], -1, sizeof(int) * MAXD);
        end[L++] = -1;
        return L - 1;
    }

    void clear() {
        L = 0;
        root = newnode();
    }

    void insert(char* buf, int _end) {
        int len = strlen(buf);
        int now = root;
        for (int i = 0; i < len; ++i) {
            if (nxt[now][(int)buf[i]] == -1) {
                nxt[now][(int)buf[i]] = newnode();
            }
            now = nxt[now][(int)buf[i]];
        }
        end[now] = _end;
    }

    void build() {
        queue<int> Q;
        fail[root] = root;
        for (int i = 0; i < MAXD; ++i) {
            if (nxt[root][i] == -1) {
                nxt[root][i] = root;
            } else {
                fail[nxt[root][i]] = root;
                Q.push(nxt[root][i]);
            }
        }

        while (!Q.empty()) {
            int now = Q.front();
            Q.pop();

            for (int i = 0; i < MAXD; ++i) {
                if (nxt[now][i] == -1) {
                    nxt[now][i] = nxt[fail[now]][i];
                } else {
                    fail[nxt[now][i]] = nxt[fail[now]][i];
                    Q.push(nxt[now][i]);
                }
            }
        }
    }
    set<int> query(char* buf) {
        int len = strlen(buf);
        int now = root;
        set<int> res;
        for (int i = 0; i < len; ++i) {
            now = nxt[now][(int)buf[i]];
            int tmp = now;
            while (tmp != root) {
                if (~end[tmp]) {
                    res.insert(end[tmp]);
                }
                tmp = fail[tmp];
            }
        }
        return res;
    }
} ac;
char buf[MAX];

int main() {
    int n, m;
    while (~scanf(" %d", &n)) {
        ac.clear();
        for (int i = 1; i <= n; ++i) {
            scanf(" %s", buf);
            ac.insert(buf, i);
        }
        ac.build();
        scanf(" %d", &m);
        int sum = 0;
        for (int i = 1; i <= m; ++i) {
            scanf(" %s", buf);
            auto v = ac.query(buf);
            if (!v.empty()) {
                ++sum;
                printf("web %d:", i);
                for (auto it = v.begin(); it != v.end(); ++it) {
                    printf(" %d", *it);
                }
                puts("");
            }
        }
        printf("total: %d\n", sum);
    }
    return 0;
}
  • hdu3065
  • 要打印匹配串：打标记，Trie上节点打前驱和字符标记。P.S.空间上还可以优化
/* **********************************************

  File Name: 3065.cpp

  Auther: zhengdongjian@tju.edu.cn

  Created Time: 2015年08月14日 星期五 11时46分10秒

*********************************************** */
#include <bits/stdc++.h>
using namespace std;

typedef pair<int, int> P;
const double EPS = 1e-8;
const double PI = acos(-1.0);

const int MAX = 50007;
const int MAXD = 128; //26 alphas
struct Trie {
    /* 
     * nxt & end is used in trie
     * fail is for ac automata
     */
    int nxt[MAX][MAXD], fail[MAX], end[MAX], pre[MAX];
    char dad[MAX];
    int root, L; //root node, length(the nodes has been malloc)[0, L]
    int newnode() {
        memset(nxt[L], -1, sizeof(int) * MAXD);
        pre[L] = -1;
        end[L++] = 0;
        return L - 1;
    }
    void clear() {
        L = 0;
        root = newnode();
    }
    void insert(char* buf) {
        int len = strlen(buf);
        int now = root;
        for (int i = 0; i < len; ++i) {
            if (nxt[now][(int)buf[i]] == -1) {
                nxt[now][(int)buf[i]] = newnode();
                pre[nxt[now][(int)buf[i]]] = now;
                dad[nxt[now][(int)buf[i]]] = buf[i];
            }
            now = nxt[now][(int)buf[i]];
        }
        ++end[now];
    }

    void build() {
        queue<int> Q;
        fail[root] = root;
        for (int i = 0; i < MAXD; ++i) {
            if (nxt[root][i] == -1) {
                nxt[root][i] = root;
            } else {
                fail[nxt[root][i]] = root;
                Q.push(nxt[root][i]);
            }
        }

        while (!Q.empty()) {
            int now = Q.front();
            Q.pop();

            for (int i = 0; i < MAXD; ++i) {
                if (nxt[now][i] == -1) {
                    nxt[now][i] = nxt[fail[now]][i];
                } else {
                    fail[nxt[now][i]] = nxt[fail[now]][i];
                    Q.push(nxt[now][i]);
                }
            }
        }
    }
    map<int, int> query(char* buf, int len = -1) {
        if (len == -1) {
            len = strlen(buf);
        }
        int now = root;
        map<int, int> res;
        for (int i = 0; i < len; ++i) {
            now = nxt[now][(int)buf[i]];
            int tmp = now;
            while (tmp != root) {
                if (end[tmp] > 0) {
                    ++res[tmp];
                }
                tmp = fail[tmp];
            }
        }
        return res;
    }
    void debug() {
        for (int i = 0; i < L; ++i) {
            printf("%d, %d, %d, [%d", i, fail[i], end[i], nxt[i][0]);
            for (int j = 1; j < MAXD; ++j) {
                printf(" %d", nxt[i][j]);
            }
            puts("]");
        }
    }
} ac;

const int MAXL = 64;
char str[MAXL];
char buffer[MAX * 40];

int main() {
    int n;
    while (~scanf(" %d", &n)) {
        ac.clear();
        for (int i = 1; i <= n; ++i) {
            scanf(" %s", str);
            ac.insert(str);
        }
        ac.build();
        scanf(" %s", buffer);
        auto mp = ac.query(buffer);
        for (auto it = mp.begin(); it != mp.end(); ++it) {
            int now = it->first;
            int idx = MAXL - 1;
            str[idx--] = '\0';
            while (now != ac.root) {
                str[idx--] = ac.dad[now];
                now = ac.pre[now];
            }
            ++idx;
            printf("%s: %d\n", str + idx, it->second);
        }
    }
    return 0;
}
  • zoj3430
  • 解码一下即可。debug了好久，最后发现Base64直接解码出来的字符可能不是 ASCII 码，就如 1111 1111 对应到 ASCII 后是 EOF… 真让人难堪。。。所以字符集开到256就可以过了…一部分调试中间修改导致整个代码看起来丑陋了一些，不愿改了。。
/* **********************************************

  File Name: 3430.cpp

  Auther: zhengdongjian@tju.edu.cn

  Created Time: 2015年08月14日 星期五 13时28分38秒

*********************************************** */
#include <bits/stdc++.h>
using namespace std;

typedef pair<int, int> P;
const double EPS = 1e-8;
const double PI = acos(-1.0);
const int MAX = 50007;
const int MAXD = 256;

/*
 * Base64 Decode
 */
static const char cb64[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
bool pool[50007];
inline int dic64(char& c) {
    if (isupper(c)) {
        return c - 'A';
    } else if (islower(c)) {
        return c - 'a' + 26;
    } else if (isdigit(c)) {
        return c - '0' + 52;
    } else {
        return c == '+' ? 62 : 63;
    }
}
void decode64(char source[], int dest[]) {
    int len = strlen(source);
    int bit = len * 6;
    memset(pool, false, sizeof(bool) * bit);
    while (source[len - 1] == '=') {
        --len;
        bit -= 8;
    }
    //printf("bit = %d\n", bit);
    for (int i = 0, j = 0; i < len; ++i, j += 6) {
        int c = dic64(source[i]);
        for (int k = j + 5; k >= j; --k) {
            pool[k] = c & 1;
            c >>= 1;
        }
    }
    int p = 0;
    for (int i = 0; i < bit; i += 8) {
        dest[p] = 0;
        for (int j = 0; j < 8; ++j) {
            dest[p] <<= 1;
            if (pool[i + j]) {
                ++dest[p];
                //dest[p] = (char)((int)dest[p] + 1);
            }
        }
        ++p;
    }
    dest[p] = -1;
}
/**********************************************/

struct Trie {
    /* 
     * nxt & end is used in trie
     * fail is for ac automata
     */
    int nxt[MAX][MAXD], fail[MAX], end[MAX];
    int root, L; //root node, length(the nodes has been malloc)[0, L]
    int newnode() {
        memset(nxt[L], -1, sizeof(int) * MAXD);
        end[L++] = 0;
        return L - 1;
    }
    void clear() {
        L = 0;
        root = newnode();
    }
    void insert(int* buf, int _id) {
        int* p = buf;
        int now = root;
        while (~(*p)) {
            if (nxt[now][*p] == -1) {
                nxt[now][*p] = newnode();
            }
            now = nxt[now][*p++];
        }
        end[now] = _id;
    }
    void build() {
        queue<int> Q;
        fail[root] = root;
        for (int i = 0; i < MAXD; ++i) {
            if (nxt[root][i] == -1) {
                nxt[root][i] = root;
            } else {
                fail[nxt[root][i]] = root;
                Q.push(nxt[root][i]);
            }
        }

        while (!Q.empty()) {
            int now = Q.front();
            Q.pop();

            for (int i = 0; i < MAXD; ++i) {
                if (nxt[now][i] == -1) {
                    nxt[now][i] = nxt[fail[now]][i];
                } else {
                    fail[nxt[now][i]] = nxt[fail[now]][i];
                    Q.push(nxt[now][i]);
                }
            }
        }
    }
    set<int> query(int* buf) {
        int* p = buf;
        int now = root;
        set<int> res;
        while (~(*p)) {
            now = nxt[now][*p++];
            int tmp = now;
            while (tmp != root) {
                if (end[tmp]) {
                    res.insert(end[tmp]);
                }
                tmp = fail[tmp];
            }
        }
        return res;
    }
    void debug() {
        for (int i = 0; i < L; ++i) {
            printf("%d, %d, %d, [%d", i, fail[i], end[i], nxt[i][0]);
            for (int j = 1; j < MAXD; ++j) {
                printf(" %d", nxt[i][j]);
            }
            puts("]");
        }
    }
} ac;

const int MAXL = 128;
char str[MAXL];
char buf[MAX];
int jj[MAX];

int main() {
    /*
    while (cin >> buf) {
        decode64(buf, buf);
        cout << buf << endl;
    }
    return 0;
    */

    int n;
    while (~scanf(" %d", &n)) {
        ac.clear();
        for (int i = 1; i <= n; ++i) {
            scanf(" %s", str);
            decode64(str, jj);
            ac.insert(jj, i);
        }
        ac.build();

        int m;
        scanf(" %d", &m);
        while (m--) {
            scanf(" %s", buf);
            decode64(buf, jj);
            printf("%d\n", (int)ac.query(jj).size());
        }
        puts("");
    }
    return 0;
}
  • poj2778 DNA Sequence
  • 给几个 DNA 串，问长度为 L 的串中，不包含上述基因的有多少种。
  • 构造矩阵A， Aij 表示从自动机的状态 i 经过1步到达状态 j 的方案数。我们考虑到，为了满足“不包含给定字符串”这个条件，那么到达的状态j不应该是一个接受状态。于是，在建立自动机时，我们将所有状态分两类，第一类是所谓合法的状态，从起始状态经过任意步到达，均不会匹配上任一个给定串；第二类是所谓非法状态，这些状态包含了匹配内容。
  • 我们只需要标记出第二类状态即可。首先，所有的接受状态都属于第二类，另外，通过自身 fail 指针可以连接到一个第二类状态的状态，也应该属于第二类状态。
  • 标记完成后，构造矩阵只需要遍历所有 L′ 个状态即可（ L′ 是自动机的总状态数）。
  • 考虑上述关系矩阵，我们发现，如果要求长度 L=1 ，则就是第一行的和；再考虑平方 B=A2 ，显然
    Bij=∑Aik∗Akj
    表示的是状态 i 经过2步到达状态 j 的方法数，即途径1个状态 k 到达j。以此类推， AL 第一行的和就表示初始状态经 L 步能到达合法状态的所有方法数目，此即答案。
/* **********************************************

  File Name: 2778.cpp

  Auther: zhengdongjian@tju.edu.cn

  Created Time: 2015年08月15日 星期六 11时04分14秒

*********************************************** */
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#include <cmath>
#include <utility>
#include <cassert>
#include <iostream>
using namespace std;

typedef pair<int, int> P;
typedef long long ll;
const double EPS = 1e-8;
const double PI = acos(-1.0);

const int MOD = 100000;
const int MAX = 107;
const int MAXD = 4;
//static const char tle[] = "ATCG";
//struct Mat;
struct Mat {
    int sz;
    ll a[MAX][MAX];

    Mat(int _sz = 1, bool flag = false): sz(_sz) {
        memset(a, 0, sizeof(a));
        if (flag) {
            for (int i = 0; i < sz; ++i) {
                a[i][i] = 1;
            }
        }
    }
    Mat operator*(const Mat& b)const {
        Mat ret(sz);
        for (int i = 0; i < sz; ++i) {
            for (int j = 0; j < sz; ++j) {
                for (int k = 0; k < sz; ++k) {
                    ret.a[i][j] += a[i][k] * b.a[k][j];
                    if (ret.a[i][j] > MOD) {
                        ret.a[i][j] %= MOD;
                    }
                }
            }
        }
        return ret;
    }
};
Mat operator^(Mat& a, int nn) {
    Mat res(a.sz, true);
    int n = nn;
    while (n) {
        if (n & 1) {
            res = res * a;
        }
        a = a * a;
        n >>= 1;
    }
    return res;
}

struct Trie {
    /* 
     * nxt & end is used in trie
     * fail is for ac automata
     */
    int nxt[MAX][MAXD], fail[MAX];
    bool end[MAX];
    int root, L; //root node, length(the nodes has been malloc)[0, L]
    int operator^(const char& c) {
        switch(c) {
            case 'A': return 0;
            case 'C': return 1;
            case 'G': return 2;
            case 'T': return 3;
            default: return 0;
        }
    }
    int getch(char ch) {
        switch(ch) {
            case 'A': return 0;
            case 'C': return 1;
            case 'G': return 2;
            default: return 3;
        }
    }
    int newnode() {
        memset(nxt[L], -1, sizeof(int) * MAXD);
        end[L++] = false;
        return L - 1;
    }
    void clear() {
        L = 0;
        root = newnode();
    }
    void insert(char* buf) {
        int len = strlen(buf);
        int now = root;
        for (int i = 0; i < len; ++i) {
            if (nxt[now][getch(buf[i])] == -1) {
                nxt[now][getch(buf[i])] = newnode();
            }
            now = nxt[now][getch(buf[i])];
            /*
            if (nxt[now][(*this) ^ buf[i]] == -1) {
                nxt[now][(*this) ^ buf[i]] = newnode();
            }
            now = nxt[now][(*this) ^ buf[i]];
            */
        }
        end[now] = true;
        //++end[now];
    }
    void build() {
        queue<int> Q;
        //fail[root] = root;
        for (int i = 0; i < MAXD; ++i) {
            if (nxt[root][i] == -1) {
                nxt[root][i] = root;
            } else {
                fail[nxt[root][i]] = root;
                Q.push(nxt[root][i]);
            }
        }

        while (!Q.empty()) {
            int now = Q.front();
            Q.pop();

            if (end[fail[now]]) {
                end[now] = true;
            }
            for (int i = 0; i < MAXD; ++i) {
                if (nxt[now][i] == -1) {
                    nxt[now][i] = nxt[fail[now]][i];
                } else {
                    fail[nxt[now][i]] = nxt[fail[now]][i];
                    Q.push(nxt[now][i]);
                }
            }
        }
    }
    int gao1gao(int n) {
        Mat res(L);
        for (int i = 0; i < L; ++i) {
            for (int j = 0; j < MAXD; ++j) {
                if (!end[nxt[i][j]]) {
                    ++res.a[i][nxt[i][j]];
                }
            }
        }
        for (int i = 0; i < L; ++i) {
            for (int j = 0; j < L; ++j) {
                printf("%2lld ", res.a[i][j]);
            }
            puts("");
        }
        res = res ^ n;
        int sum = 0;
        for (int i = 0; i < L; ++i) {
            sum += res.a[0][i];
            if (sum >= MOD) {
                sum %= MOD;
            }
        }
        return sum;
    }
} ac;
char str[MAX];

int main() {
    int m, n;
    while (cin >> m >> n) {
        ac.clear();
        for (int i = 0; i < m; ++i) {
            cin >> str;
            ac.insert(str);
        }
        ac.build();
        cout << ac.gao1gao(n) << endl;
    }
    return 0;
}
  • hdu2243
  • 和上述类似，求出长度L以内不合法的，再用总数减去即可。为啥不能直接从正面求捏？考虑上面对关系矩阵的幂的分析过程即可。显然我们需要求得
    ∑i=1L|A|i
    于是构造矩阵
    ∣∣∣A0EE∣∣∣
    其中 E 表示单位矩阵。求出该矩阵的L+1次方，则右上角的分块矩阵即是我们要求的和
  • 另外，由于上面构造了一个需要求 L+1 次方的矩阵，不能保证 L+1 在 int 范围内，需要 long long 或者先算 L 次再额外算一次。
  • 求出
    B=∑i=1L|A|i
    后(下标都从0开始算),
    ans=∑i=1L26i−∑i=L2L−1B0i

    • P.S. ∑Li=126i 部分同样可以构造一个矩阵
      ∣∣∣26011∣∣∣
      通过其 L+1 次方求得，同样地，自己推一推就好了。
/* **********************************************

  File Name: 2243.cpp

  Auther: zhengdongjian@tju.edu.cn

  Created Time: 2015年08月16日 星期日 13时43分01秒

*********************************************** */
#include <bits/stdc++.h>
using namespace std;

typedef pair<int, int> P;
typedef long long ll;
typedef unsigned long long ull;
const double EPS = 1e-8;
const double PI = acos(-1.0);

const int MAX = 64;
const int MAXD = 26;
struct Mat {
    int sz;
    ull a[MAX][MAX];
    Mat(int _sz = MAX, bool flag = false): sz(_sz) {
        memset(a, 0, sizeof(a));
        if (flag) {
            for (int i = 0; i < sz; ++i) {
                a[i][i] = 1;
            }
        }
    }
    Mat operator*(const Mat& b)const {
        Mat res(sz);
        for (int i = 0; i < sz; ++i) {
            for (int j = 0; j < sz; ++j) {
                for (int k = 0; k < sz; ++k) {
                    res.a[i][j] += a[i][k] * b.a[k][j];
                }
            }
        }
        return res;
    }
    Mat operator^(ll n)const {
        Mat a(*this);
        Mat res(sz, true);
        while (n) {
            if (n & 1) {
                res = res * a;
            }
            a = a * a;
            n >>= 1;
        }
        return res;
    }
};
struct Trie {
    int root, L;
    int nxt[MAX][MAXD], fail[MAX];
    int end[MAX];
    void clear() {
        L = 0;
        root = newnode();
    }
    int newnode() {
        memset(nxt[L], -1, sizeof(int) * MAXD);
        end[L] = false;
        return L++;
    }
    void insert(const char* s) {
        int len = strlen(s);
        int now = root;
        for (int i = 0; i < len; ++i) {
            if (nxt[now][s[i] - 'a'] == -1) {
                nxt[now][s[i] - 'a'] = newnode();
            }
            now = nxt[now][s[i] - 'a'];
        }
        end[now] = true;
    }
    void build() {
        queue<int> Q;
        fail[root] = root;
        for (int i = 0; i < MAXD; ++i) {
            if (nxt[root][i] == -1) {
                nxt[root][i] = root;
            } else {
                fail[nxt[root][i]] = root;
                Q.push(nxt[root][i]);
            }
        }
        while (!Q.empty()) {
            int now = Q.front();
            Q.pop();

            if (end[fail[now]]) {
                end[now] = true;
            }
            for (int i = 0; i < MAXD; ++i) {
                if (nxt[now][i] == -1) {
                    nxt[now][i] = nxt[fail[now]][i];
                } else {
                    fail[nxt[now][i]] = nxt[fail[now]][i];
                    Q.push(nxt[now][i]);
                }
            }
        }
    }
    ull gao1gao(ll l) {
        Mat res(L * 2);
        for (int i = 0; i < L; ++i) {
            for (int j = 0; j < MAXD; ++j) {
                if (!end[nxt[i][j]]) {
                    ++res.a[i][nxt[i][j]];
                }
            }
        }
        for (int i = L; i < 2 * L; ++i) {
            res.a[i][i] = 1;
            res.a[i - L][i] = 1;
        }
        /*
        cout << "------------" << endl;
        for (int i = 0; i < 2 * L; ++i) {
            for (int j = 0; j < 2 * L; ++j) {
                printf("%2llu ", res.a[i][j]);
                //cout << res.a[i][j] << ' ';
            }
            cout << endl;
        }
        Mat res1 = res ^ l;
        ull sum1 = 0ULL;
        for (int i = 0; i < L; ++i) {
            sum1 += res1.a[0][i];
        }
        return sum1;
        */
        res = res ^ (l + 1);

        Mat tp(2);
        tp.a[0][0] = 26, tp.a[0][1] = tp.a[1][1] = 1;
        tp = tp ^ (l + 1);

        ull sum = tp.a[0][1];
        for (int i = L; i < 2 * L; ++i) {
            sum -= res.a[0][i];
        }
        return sum;
    }
} o_o;

int main() {
    int n;
    ll l;
    while (cin >> n >> l) {
        char str[MAX];
        o_o.clear();
        for (int i = 0; i < n; ++i) {
            cin >> str;
            o_o.insert(str);
        }
        o_o.build();

        cout << o_o.gao1gao(l) << endl;
    }
    return 0;
}
bit_line
关注
专栏目录
ac自动机最详细的讲解，让你一次学会ac自动机。
creatorx的博客
05-02 6万+
在没学ac自动机之前，觉得ac自动机是个很神奇，很高深，很难的算法，学完之后发现，ac自动机确实很神奇，很高深，但是却并不难。 我说ac自动机很神奇，在于这个算法中失配指针的妙处（好比kmp算法中的next数组），说它高深，是因为这个不是一般的算法，而是建立在两个普通算法的基础之上，而这两个算法就是kmp与字典树。所以，如果在看这篇博客之前，你还不会字典树或者kmp算法，那么请先学习字典树或者km
AC自动机步骤详解
问鼎63的博客
08-12 2340
AC自动机 算法意义： 求多个字符串是否在主串中出现过。可依据情况分别求出出现次数，出现位置等。 学习基础： 要搞懂AC自动机，先得有模式树（字典树）Trie和KMP模式匹配算法的基础知识。 AC自动机的构造： 1.构造一棵Trie，作为AC自动机的搜索数据结构。 2.构造fail指针，使当前字符失配时跳转到具有最长公共前后缀的字符继续匹配。如同 KMP算法一样， AC自
AC自动机---求找出每个字符串出现的具体次数
winycg的博客
10-28 2592
Description 小t非常感谢大家帮忙解决了他的上一个问题。然而病毒侵袭持续中。在小t的不懈努力下，他发现了网路中的“万恶之源”。这是一个庞大的病毒网站，他有着好多好多的病毒，但是这个网站包含的病毒很奇怪，这些病毒的特征码很短，而且只包含“英文大写字符”。当然小t好想好想为民除害，但是小t从来不打没有准备的战争。知己知彼，百战不殆，小t首先要做的是知道这个病毒网站特征：包含多少不同的病
poj1204之AC自动机
Stephen
07-24 1870
AC自动机
子串总长度 sam
twh233的算法blog
10-18 433
子串总数*子串总长。 总数还是父亲节点-儿子节点的长度，另外子串长度就是len[fa[i]]+1,len[fa[i]]+2,...+len[i] //china no.1 #pragma comment(linker, "/STACK:1024000000,1024000000") #include #include #include #include #include
AC自动机小结
zhangtingxiqwq的博客
09-11 456
AC自动机是一种多模匹配算法。
ac自动机 匹配最长前缀_AC自动机算法
weixin_34335039的博客
01-15 740
AC自动机简介：首先简要介绍一下AC自动机：Aho-Corasick automation，该算法在1975年产生于贝尔实验室，是著名的多模匹配算法之一。一个常见的例子就是给出n个单词，再给出一段包含m个字符的文 章，让你找出有多少个单词在文章里出现过。要搞懂AC自动机，先得有字典树Trie和KMP模式匹配算法的基础知识。KMP算法是单模式串的字符匹配算 法，AC自动机是多模式串的字符匹配算法。A...
AC自动机算法小结
在思索中前行！
04-27 1368
AC自动机,可惜不能自动AC 转载：飘过的小牛   OIer55242 简介 Aho-Corasick automation 该算法在1975年产生于贝尔实验室，是著名的多模匹配算法之一。一个常见的例子就是给出n个单词，再给出一段包含m个字符的文章，让你找出有多少个单词在文章里出现过。要搞懂AC自动机，先得有字典树Trie和KMP模式匹配算法的基础知识。KMP算法是单模式
通俗易懂のAC自动机小结
未来可期。
06-23 867
AC自动机小结AC自动机的思想 = trie树 + KMPAC自动机是用来干什么的呢 多模式串匹配一个文本串建成一个AC自动机需要三步1. 构建trie树    2. 构建fail指针   3. 模式串匹配首先用模式串建成一颗trie树 在每个模式串末尾打上标记 表示这是一个模式串的末尾树上的每一个节点都对应一个fail指针 作用和KMP中的nex差不多 如果我可以通过fail指针走向一个节点 那...
【算法笔记】Aho-Corasick 算法（AC自动机） 小结
slowlight93的专栏
08-10 643
参考： 《训练指南》 http://codeforces.com/blog/entry/14854这个改进《训练指南》中说过， 本文的目的是总结并实现一个自用的模板。。 AC自动机每个节点有一个 fail 指针， 作用与KMP中相同。 假如我们的节点是这样的// link 就是 fail指针 struct Node { Node *go[CharSet], *link; in
数据结构与算法：36 | AC自动机：如何用多模式串匹配实现敏感词过滤功能？
zj
08-07 341
文章目录基于单模式串和 Trie 树实现的敏感词过滤经典的多模式串匹配算法：AC 自动机解答开篇内容小结 很多支持用户发表文本内容的网站，比如 BBS，大都会有敏感词过滤功能，用来过滤掉用户输入的一些淫秽、反动、谩骂等内容。你有没有想过，这个功能是怎么实现的呢？ 实际上，这些功能最基本的原理就是字符串匹配算法，也就是通过维护一个敏感词的字典，当用户输入一段文字内容之后，通过字符串匹配算法，来查找用户输入的这段文字，是否包含敏感词。如果有，就用“***”把它替代掉。 我们前面讲过好几种字符串匹配算法了，它们都
数据结构与算法36丨AC自动机：如何用多模式串匹配实现敏感词过滤功能？
qq_53280238的博客
07-15 820
很多支持用户发表文本内容的网站，比如 BBS，大都会有敏感词过滤功能，用来过滤掉用户输入的一些淫秽、反动、谩骂等内容。你有没有想过，这个功能是怎么实现的呢？实际上，这些功能最基本的原理就是字符串匹配算法，也就是通过维护一个敏感词的字典，当用户输入一段文字内容之后，通过字符串匹配算法，来查找用户输入的这段文字，是否包含敏感词。如果有，就用“***”把它替代掉。我们前面讲过好几种字符串匹配算法了，它们都可以处理这个问题。但是，对于访问量巨大的网站来说，比如淘宝，用户每天的评论数有几亿、甚至几十亿。
AC自动机+DP小结 （一）
ddyyxx的程序员之路
11-13 5589
好久没有更新博客了，最近真是懒到家了，南京赛前重点复习了下AC自动机+DP方面的题，写下来总结一下。 HDU 2457  DNA repair http://acm.hdu.edu.cn/showproblem.php?pid=2457 题意：
AC自动机算法及模板
楠先生
05-08 6626
关于AC自动机 AC自动机：Aho-Corasickautomation，该算法在1975年产生于贝尔实验室，是著名的多模匹配算法之一。一个常见的例子就是给出n个单词，再给出一段包含m个字符的文章，让你找出有多少个单词在文章里出现过。要搞懂AC自动机，先得有模式树（字典树）Trie和KMP模式匹配算法的基础知识。AC自动机算法分为3步：构造一棵Trie树，构造失败指针和模式匹配过
POJ 1204 AC自动机
Dan__ge的博客
05-16 4833
点击打开链接 题意：给个L*C的字符串矩阵，W个询问，对每个询问输出这个串第一次出现的位置及方向，共有8个方向，用A~H表示 思路：用AC自动机进行快速匹配，细节处理特别多，不看题解的话应该会WA很多次，还有一个处理的非常巧妙地地方，就是我们要输出第一次出现的位置，而AC自动机不能回溯，所以将串反着构造进字典树里，真是神犇，然后方向设置时也反着就可以了#include #include #
Amazon S3：S3静态网站托管教程.docx
最新发布
11-12
Amazon S3：S3静态网站托管教程.docx
基于支持向量机SVM-Adaboost的风电场预测研究附Matlab代码.rar
11-12
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。
基于花朵授粉优化算法FPA优化TCN-BiGRU-Attention实现光伏数据回归预测附Matlab代码.rar
11-12
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 替换数据可以直接使用，注释清楚，适合新手
【粗糙面】基于matlab一维介质粗糙面双站散射系数计算【含Matlab源码 9130期】.mp4
11-12
Matlab领域上传的视频均有对应的完整代码，皆可运行，亲测可用，适合小白； 1、代码压缩包内容 主函数：main.m； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2019b；若运行有误，根据提示修改；若不会，私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开main.m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可私信博主； 4.1 博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作
信息学奥赛AC自动机模板使用指南
资源摘要信息:"AC自动机（Aho-Corasick自动机）是一种高效处理多模式字符串匹配问题的数据结构，主要用于信息学奥林匹克竞赛（如NOI、IOI）等算法竞赛中。AC自动机模板是一种为了解决该问题而编写的程序代码模板，它...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值