• P5357【模板】AC自动机(二次加强版)


    题目传送门

    一、题解分析

    因为是什么二次加强版,所以大家先去做一下加强版吧,做法差不多。

    没做过的看上面的链接,有一些变量名可能会在刚才那一篇\(blog\)出现过,所以建议大家再去过一下。

    好了,看到这里大家都一定做过加强版了吧,那么这道题的做法也是差不多的:我们这一次不需要求出现最多的字符串啦,直接将\(cnt\)数组输出就好了!(应该都知道\(cnt\)数组是什么吧,就是统计每个模式串在文本串出现多少次的数组)

    但重复的单词有没有影响啊!有啊!对于加强版这一次重复的单词就会有影响啦,怎么办?

    这道题有相同字符串要统计,设当前字符串是第\(i\)个,我们用一个\(family[i]\)数组存(当前字符串在\(Trie\)中的那个位置输入模式串序号),最后把\(ans[family[i]]\)输出就\(OK\)了。另外\(id\)只在第一次赋值时变化,其他都不变。

    本题思路很简单,如果你做过加强版的话。
    这个思路很好搞,就是简单统计出现次数,然后输出。
    不过如果你直接交会发现花花绿绿的,红绿蓝紫齐全。
    我当时就是非常高兴的把加强版的代码改了改交了上去:

    二、朴素版本

    //本代码手动吸氧,可以得76分
    #include <bits/stdc++.h>
    using namespace std;
    const int N = 2 * 1e5 + 10;
    const int M = 2 * 1e6 + 10; //最大长度 2*10^6,比加强版大了一倍
    char s[N], T[M];            //模式串与文本串
    /*
    每个模式串Si在T中出现的次数
    数据不保证任意两个模式串不相同。
    
    理解:
    1、如果能保证模式串不重复,那么就是加强版。
    2、由于模式串可能重复,所以需要进行一下处理:采用一个类似于并查集的思想:
    因为模式串可能有重复的,而我们在本题中不关心第几个模式串出现几次,只关心“长着一样的字符串,出现了几次”
    比如:第2、3两个序号输入的模式串都是 abcd,其实,我们关注的是 abcd出现的次数,而不是 2和3出现的次数。
    因为,采用的办法就是:一样的字符串,第一次录入记录它是family的族长,后面再输入一样的字符串,都使用前面的族长编号做为自己家族的标识
    */
    int n;              //模式串数量
    int tr[N][26], idx; // Trie树
    int id[N];          // 节点号-mapping->模式串
    int ne[N];          // AC自动机的失配数组 fail指针
    int ans[N];         //记录答案,每个模式串被命中几次
    int family[N];      //每个输入的模式串x,都隶属于某一个family[x],黄海称之为家庭,类似于并查集?
    
    void insert(char *s, int x) {
        int p = 0;
        for (int i = 0; s[i]; i++) {
            int t = s[i] - 'a';
            if (!tr[p][t]) tr[p][t] = ++idx;
            p = tr[p][t];
        }
        if (!id[p]) id[p] = x; //当字符串重复时,保留第一个录入的序号
        family[x] = id[p];     // 记录族长信息
    }
    
    int q[N];
    void bfs() {
        int hh = 0, tt = -1; //将队列的头和尾变量写在这里,可以有效防止多组测试数据的初始化问题
        for (int i = 0; i < 26; i++)
            if (tr[0][i]) q[++tt] = tr[0][i];
        while (hh <= tt) {
            int p = q[hh++];
            for (int i = 0; i < 26; i++) {
                int t = tr[p][i]; // p状态,通过i这条边,到达的新状态t; 也可以理解为是前缀
                if (!t)
                    tr[p][i] = tr[ne[p]][i]; //节点 指向父节点失配指针的i这条边
                else {
                    ne[t] = tr[ne[p]][i]; //失配指针指向父节点失配指针的i这条边
                    q[++tt] = t;          //存在的要入队列
                }
            }
        }
    }
    
    //查询字符串s在AC自动机中出现的次数
    void query(char *s) {
        int p = 0;                   //从root出发
        for (int i = 0; s[i]; i++) { //枚举文本串每个字符
            int j = s[i] - 'a';      // j为当前字符的映射数字
            //每走到一个位置,需要进行检查
            int k = tr[p][j];            // k为拷贝出来的临时变量,准备游标去一路向上寻找
            while (k) {                  //如果还没有到达root节点
                if (id[k]) ans[id[k]]++; //如果k这个节点是某个模式串的终点,此模式串号 id[k] 对应的命中个数+1
                k = ne[k];               //继续向上游动
            }
            p = tr[p][j]; //走Trie树路径
        }
    }
    
    int main() {
        scanf("%d", &n);
        //由模式串构建Trie树
        for (int i = 1; i <= n; i++) {
            scanf("%s", s);
            insert(s, i);
        }
        //构建AC自动机
        bfs();
    
        //输入文本串
        scanf("%s", T);
        //查询
        query(T);
        //对于每一个模式串,输出它代表的字符串在文本串中出现的次数
        for (int i = 1; i <= n; i++) printf("%d\n", ans[family[i]]);
        return 0;
    }
    

    那么我们现在得到的算法是直接跑自动机跳\(fail\)树,然后每跳到一个标记点就计数加一。
    然后我们考虑对其进行优化,

    我们考虑当我们匹配到单词的时,我们会不断地去跳\(fail\),同一个点会可能被跳多次。
    那么我们可以想一下把\(fail\)指针单独建出来他是个什么样子的。

    \(emmm\)

    懒得画,它就是一棵树。

    那么对于这一棵树,我们每次匹配时都会去更新它的父亲节点(\(fail\)树),那么对于树上的一条链,每一个子节点也有父子关系,他们会有共同的祖先。对于一对被遍历过的父子节点,它们的共同祖先显然会被父亲跳一次再被儿子跳一次,如果能够减少跳的次数,同时不丢失贡献,那么我们就能降低复杂度,从而完成本题。

    那么我们思考一下,我们在跑自动机时如果先不跳\(fail\),而是单纯的跑\(trie\)树,是比连跑带跳(\(fail\))复杂度小不少的。那么跑完\(trie\)树,我们得到的是什么?

    我们得到的是文本串在自动机上跑过的痕迹(脚印),我们也就得到了每个节点(不跳\(fail\))被遍历的次数,
    在这些节点中,我们可以拿出来再更新\(fail\)

    这时我们应该想一下既然都拿出来了,有没有什么方法能优化更新?
    这样我们就需要思考\(fail\)树的性质
    我们思考一下\(fail\)指针的建立:当前节点的 / 父亲节点的 / \(fail\)指针指向节点的 / 子节点 。
    \(fail\)指针在树上跳时是一定向上跳的,最下面的节点会更新上面的父亲节点。
    那么一个点被遍历的次数就是:\(trie\)树上遍历次数 + \(fail\)树上子节点被遍历次数

    而子节点被遍历次数又取决于其\(trie\)树上遍历次数和自身子节点的个数。
    那么最下面的点是不需要被其他点通过\(fail\)更新的
    如果最下面的点更新过自己的父亲节点,那么它的父亲节点也就是次深的点就成了刚才最下面的点的状态。
    而且一个节点只会被更新一次。
    于是我们就得到了\(trie\)树的更新方法, 通过拓扑序更新\(fail\)树,从底往上不断累加,最后输出结果。
    更新过程有点像线段树?

    三、拓扑序优化递推版本

    #include <bits/stdc++.h>
    using namespace std;
    const int N = 200010;  //模式串长度
    const int M = 2000010; //文本串长度
    int n;                 //模式串个数
    char s[N], T[M];       //模式串,文本串
    
    // Trie树
    int tr[N][26], idx, id[N];
    void insert(int x) {
        int p = 0;
        for (int i = 0, p = 0; s[i]; i++) {
            int t = s[i] - 'a';
            if (!tr[p][t]) tr[p][t] = ++idx;
            p = tr[p][t];
        }
        id[x] = p;
    }
    
    //构建AC自动机
    int q[N], ne[N];
    void bfs() {
        int hh = 0, tt = -1;
        for (int i = 0; i < 26; i++)
            if (tr[0][i]) q[++tt] = tr[0][i];
        while (hh <= tt) {
            int t = q[hh++];
            for (int i = 0; i < 26; ++i) {
                if (tr[t][i]) {
                    ne[tr[t][i]] = tr[ne[t]][i];
                    q[++tt] = tr[t][i];
                } else
                    tr[t][i] = tr[ne[t]][i];
            }
        }
    }
    
    int f[N];
    void query(char *s) {
        int p = 0;
        for (int i = 0; s[i]; i++) { //枚举文本串每一个字符
            int t = s[i] - 'a';      //字符映射的数字t,可以理解为边
            p = tr[p][t];            //走进去,到达的位置替换p
            f[p]++;                  //标识此位置有人走过,记录走的次数
        }
        // Trie树中的节点个数=root(1个)+有效字符数(idx)
        //从大到小枚举,是因为这是符合拓扑序的,倒着来可以形成递推的效果
        for (int i = idx; i; i--) f[ne[q[i]]] += f[q[i]]; //一路向上,计算叠加值
    }
    
    int main() {
        scanf("%d", &n);
        for (int i = 1; i <= n; i++) {
            scanf("%s", s);
            insert(i);
        }
        //构建AC自动机
        bfs();
        //文本串
        scanf("%s", T);
        query(T);
        //输出
        for (int i = 1; i <= n; i++) printf("%d\n", f[id[i]]);
        return 0;
    }
    
  • 相关阅读:
    c++ static_cast和dynamic_cast详解
    python 字符串格式化 format
    python zip() 函数
    零零散散的python笔记 2
    PAT 1017
    PAT 1016
    PAT 1015
    Jordan Lecture Note-8: The Sequential Minimal Optimization Algorithm (SMO).
    Jordan Lecture Note-7: Soft Margin SVM
    PAT 1014
  • 原文地址:https://www.cnblogs.com/littlehb/p/16266602.html
Copyright © 2020-2023  润新知