关于双数组字典树ac自动机递归版实现的理解

最新推荐文章于 2024-08-06 00:28:47 发布
最新推荐文章于 2024-08-06 00:28:47 发布
阅读量1.1k 收藏 1
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_38331384/article/details/86618020
版权

关于双数组字典树ac自动机递归版实现的理解

字典树

简介:

字典树又名单词查找树是一种结构简单好用的树型结构:电影应用是用于统计,排序和保存大量字符串,优点是利用字符串公共祖先减少查询时间,减少无所谓的字符串比较

树形结构

树形结构的点代表的是集合,边代表的是关系,而在字典树中,字符对应的是边,节点则是链接上一个字符和这个字符的关系,是字符构成单词的关键.如图所示

字典树)

结构定义
#define BASE 'a'
#define SIZE 26

typedef struct Node{
    int flag;
    struct Node *next[SIZE];
}Node;

解释

flag表示的从根节点到这个节点是否有独立成次的节点,如果有就标记成1,没有则为0

struct Node *next[SIZE]是26个英文字母的指针,指向26个儿子节点

创建新的节点
Node *getNewNode() {
    return (Node *)calloc(sizeof(Node), 1);
}
插入操作
int insert(Node *node, const char *str) {
    Node *p = node;
    int cnt = 0,ind = 0;
    while (str[0]) {
        ind = str[0] - BASE;
        if (p->next[ind] == NULL) {
            p->next[ind] = getNewNode();
            cnt++;
        }
        p = p->next[ind];
        str++;
    }
    p->flag= 1;
    return cnt;
}

解释

str是一个字符指针，最后一位是0作为结束字符，所以我们可以用它来作为while的循环条件

ind获取相应的儿子下边，如果没有这个儿子节点我们就申请一个空间，然后指针后移，如果有，我们就直接后移．

最后当一个单词查找完成之后我们让最后一个节点的flag为１，表示从跟节点到这个节点的一条支路上存在一个单词

cnt为计数器表示又申请了多少个节点空间

查找操作
int search(Node *node, const char *str) {
    Node *p = node;
    int ind = 0;
    while (p && str[0]) {
        ind = str[0] - BASE;
        p=p->next[ind];
        str++;
    }
    return (p && p->flag);

解释

我们沿着str这条路在字典树的走，，如果p为空或者str走到尽头的时候进行返回

返回值如果p不为空并且p->flag为１时存在这个单词，其他情况均不存在

回收操作
void clear(Node *node) {
    if (node == NULL) return ;
    for (int i = 0; i < BASE; i++) {
        clear(node->next[i]);
    }
    free(node);
    return ;
}

解释

所有节点指针进行回收

测试程序
int main() {
    Node *root = getNewNode();
    int n = 0;
    char str[50];
    scanf("%d", &n);
    for (int i = 0; i < n; i++) {
        scanf("%s", str);
        insert(root,str);
    }
    while (scanf("%s", str)) {
        printf("search %s = %d\n", str,search(root, str));
    }
    clear(root);
    return 0;
}

双数组字典树

简介

双数组字典树与一般的字典树指示在存储结构上不同，理论结构上一样的．由原来的依靠指针寻找儿子节点位置的方式变成了计算寻找．用双数组存储字典树的原因是应为我们一般的字典树存储儿子节点都需要申请一个拥有２６个儿子节点指针的新的节点，而我们往往只是用到了其中的几个．所以用双数组的方式取存储的化利用效率比较高

双数组有一个ｂａｓｅ数组和ｃｈｅｃｋ数组，ｂａｓｅ数组存储的是用来寻找儿子节点位置信息．例如父亲节点的下标是ind 则儿子节点的下标可以是arr[ind].base + i (0<i < 26),当然为了确定arr[ind].base + i 为下标的节点是不是他的孩子所以我们就还需要一个数组用来存储儿子节点的父亲下标就是check数组 如果 arr[arr[ind].base + i].check == ind则证明他是ind号下标的一个儿子节点,那么我们怎能比表示独立成词呢,这个方法有几种,你可以在申请一个数组用来记录以ind为下标的节点是不是单独成词,当然还有一个更加巧妙的方法,我们的数字都是有正负之分的,所以当check位负数时证明形成了以这个节点为止的单词,同事判断他是不是父亲节点的儿子就改成了abs(arr[arr[ind].base + i].check) == ind

结构定义
typedef struct DANode{
    int base,check;
}DANode;
申请数组
DANode *getNewDANode(int n){
    return (DANode *)calloc(sizeof(DANode), n);
}
将字典树转换成一颗双数组字典树操作
//获取base值,先看下面的
int get_base(Node *node, DANode *data) {
    int base = 1,flag = 0;
    while (!flag) {
        base++;
        flag = 1;
        for (int i = 0; i < SIZE; i++) {
            if (node->next[i] == NULL) continue;//没有这个儿子节点返回
            if (data[base + i].check == 0) continue;//没有信息返回
            //运行到这一行的条件是,有data[base + i].check 有信息也就是有父亲节点
            //所以我们把flag置为0,当flag位0时表示可以进行下一次循环,然后我们跳出for循环
            //因为已经没有必要继续下去了,以这个base为下标的不能存储所有儿子节点
            flag = 0;
            break;
        }
    }
    return base;
}

void build(Node *node, DANode * data, int ind) {
    if(node == NULL) return ;
    if (node->flag) data[ind].check = -data[ind].check;
    //表示儿子独立成词
    data[ind].base = get_base(node, data);
    for (int i = 0; i < SIZE; i++) {
        if (node->next[i] == NULL) continue;
        data[data[ind].base + i].check = ind;
        //儿子节点记录父亲节点的下标信息
    }
    for (int i = 0; i < SIZE; i++) {
        if (node->next[i] == NULL) continue;
        build(node->next[i],data,data[ind].base + i);
    }
    return ;
}
查找操作
int searchD(DANode *data, const char *str) {
    int p = 1;
    for (int i = 0; str[i]; i++) {
        int delta = str[i] - BASE;
        //节点是那个字符的信息
        int check = abs(data[data[p].base + delta].check);
        //儿子节点的父亲
        if (check - p) return 0;
        //如果父亲是这个节点的儿子,则check等于p,if条件位0,
        p = data[p].base + delta;
        //坐标后移
    }
    return data[p].check < 0;
}
注意事项

我们的base值最小为2,0号下标不存储东西,1号下标只用来存储跟节点,1号数组的check为0

测试程序
int main() {
    Node *root = getNewNode();
    int n = 0,cnt1 = 1;
    char str[50];
    scanf("%d", &n);
    for (int i = 0; i < n; i++) {
        scanf("%s", str);
        cnt1 += insert(root,str);
    }
    DANode *trie = getNewDANode(cnt1 * 10);
    build(root,trie,1);
    while (scanf("%s", str)) {
        printf("search %s = %d\n", str, searchD(trie, str));
    }
    clear(root);
    return 0;
}

ac自动机-层序实现

ac自动机是在字典树的基础上添加了一个失败指针,指向等价的节点位置,用来防止匹配失败时的文本串回退.与kmp的next数组相仿.跟节点的失败指针位空,第一层的失败指针一定指向跟节点,

结构定义
typedef struct Node{
    int flag;
    struct Node *next[SIZE],*fail;
}Node;
fail指针的建立
void build_ac(Node *root) {
    #define MAX_N 1000
    if (root == NULL) return ;
    Node **queue = (Node **)malloc(sizeof(Node*) * MAX_N);
    //用来存储每一层的节点,因为可能有多次回退失败指针的情况,所以在建立下一层失败指针的时候,本层的失败指针一定要建立,用层序遍历来实现比较方便
    int head = 0,tail = 0;
    queue[tail++] = root;
    while (head < tail) {
        Node *new_node = queue[head++];
        //出队
        for (int i = 0; i < SIZE; i++) {
            if (new_node->next[i] == NULL) continue;
            //没有子孩子返回
            Node *p = new_node->fail;
            //有子孩子,换出他的失败指针
            while (p && p->next[i] == NULL) p = p->fail;
            //向上寻找看是否有等价节点有这个字符的孩子,直到根节点为止
            if (p == NULL) new_node->next[i]->fail = root;
            //如果没有让这个孩子节点的失败指针指向跟
            else new_node->next[i]->fail = p->next[i];
            //如果存在让孩子的节点的失败指针,指向p相应的孩子
            queue[tail++] = new_node->next[i];
            //入队
        }
    }
    #undef MAX_N
    return ;
}
字符串中的查找
int search_ac(Node *root, const char *str) {
    if(root == NULL) return 0;
    Node *p = root;
    int cnt = 0;
    for (int i = 0; str[i]; i++) {
        while (p && p->next[str[i] - BASE] == NULL) p = p->fail;
        //看这个节点或者这个节点的等价节点有没有这个孩子
        if(p == NULL) p = root;
        //如果没有,则返回根节点
        else p = p->next[str[i] - BASE];
        //如果有p向下匹配
        Node *q = p;
        while (q) {
            //遍历失败指针向上寻找,看是否存在有着相同后缀的字符串独立成词
            cnt += q->flag;
            q = q->fail;
        }
    }
    return cnt;
}
测试程序
int main() {
    Node *root = getNewNode();
    int n = 0;
    char str[50];
    scanf("%d", &n);
    for (int i = 0; i < n; i++) {
        scanf("%s", str);
        insert(root,str);
    }
    build_ac(root);
    while (scanf("%s", str)) {
        printf("search %s = %d\n", str, search_ac(root, str));
    }
    clear(root);
    return 0;
}

ac自动机-递归实现

推导思路

先正常推导递归版思路

  1. 首先我们接受一个节点，就去建立他儿子节点的失败指针，可以得到如下代码
void build_automaton(TrieNode *node) {
    if (node == NULL) return ;
    //如果节点为空返回
    for (int i = 0; i < SIZE; i++) {
        if (node->next[i] == NULL) continue;
        //如果他没有这个孩子结束本次循环
        Node *p = node->fail;//他的的失败指针
        while (p && p->next[i] == NULL) {
            //看他失败指针有没有这个孩子，没有就递归沿着失败指针向上找
            p = p->fail;
        }
        if (p == NULL) p = root;
        //代表没找到则失败指针位跟节点
        else p = p->next[i];
        //找到了他的失败指针就是ｐ相应位置的孩子
        node->next[i]->fail = p;
        //失败指针赋值
        build_automaton(node->next[i]);
        //去建立儿子节点的失败指针
    }
    return ;
}

  1. 上面一个是基础版本的思路框架，但是会有几个问题？当我们沿着一条路往下走的时候，失败指针会去递归匹配失败指针的失败指针，但是我们只建立了这个分支的失败指针，其他路的失败指针我们还没有进行建立，所以我们需要跳转到那个节点去建立条支路的失败指针（如图）,（当我们建立８号节点的失败指针时，６号节点下面是没有ｄ字符的，但是从一个正常自动机的角度来说６号节点的失败指针是４，４下面有ｄ字符）

    又因为建立一个节点的失败指针是根据他的父亲节点的失败指针去建立的所以，我们个结构体添加一个父亲指针，指向他父亲的位置，用来建立连通这条支路，以便建立这条支路的失败指针，实现这些会得到一下代码

    一颗小树

//上面解释过得代码我们就不进行解释了
void build_automaton(TrieNode *node) {
    if (node == NULL) return ;
    if (node->fail == NULL) build_automaton(node->father);
    //先看第一步
    //第二步，从第一步跳转而来，因为本条支路的所有的节点的失败指针都没有确定我们就可以
    //通过这句话递归向上，找到根节点，根节点父亲节点为空，上面那个ｉｆ为这个跳转的截止条件
    for (int i = 0; i < SIZE; i++) {
        if (node->next[i] == NULL) continue;
        if (node->next[i]->fail) continue;
        //第三步，因为我们一直跳到了根节点，上一次到根节点的状态与这次到根节点的状态唯一的区别呢就是，又多了一条孩子失败指针已经确立了，为了避免重复确立我们不去搜索已经确立失败指针的子孩子
        //同时如果出现我们上面那个图的情况的时候，每次都遍历第一条支路，到达ｃ节点的时候就会递归向上形成一条环路．
        Node *p = node->fail;
        while (p && p->next[i] == NULL) {
            //第一步，如果他的失败指针的失败指针没有确立我们就确立失败指针的父亲节点
            if (p->fail == NULL) build_automaton(p->father);
            p = p->fail;
        }
        if (p == NULL) p = root;
        else p = p->next[i];
        node->next[i]->fail = p;
        build_automaton(node->next[i]);
    }
    return ;
}

成环问题请看上面第三步

详细讨论：我们上图演示的是四层就可以形成一条环路，四层以上可不可以成环呢？

我们可以知道本层父亲节点失败指针一定是指向根节点的．所以只有两种情况一中是根节点下有那个节点，跳出while (p && p->next[i] == NULL)，　二是跟节点下没有这个节点，进行递归，但是因为跟节点没有父亲节点，所以递归进去就知道被第一行的ｉｆ返回了．所以跳出while (p && p->next[i] == NULL)，继续向下进行，不会有成环的可能．

  1. 不知道你有没有注意到当节点一直递归到最上层的时候，如果没有匹配到的节点，我们就会将他的失败指针指向根节点，但是我们并没有说根节点是怎么来的，有几种可行的方案，一设立全局变量，二将根节点设置成为函数参数，三，如果匹配不成功，节点ｐ是不断向上跳的，而且每次都去确立那一条支路的失败指针，如图所示，当第一次返回时绝大部分的失败指针都已经确定，然后就变成了非递归版的不断向上找失败时对应节点了

    当完全失败周ｐ等于ＮＵＬＬ，则上一次ｐ指针一定等一ｒｏｏｔ，所以我们可以建立一个指针保存上一次的值

    另一颗小树

void build_automaton(TrieNode *node) {
    if (node == NULL) return ;
    if (node->fail == NULL) build_automaton(node->father);
    for (int i = 0; i < SIZE; i++) {
        if (node->next[i] == NULL) continue;
        if (node->next[i]->fail) continue;
        Node *p = node->fail, *pre_p = node;
        //保存上一次的值
        while (p && p->next[i] == NULL) {
            if (p->fail == NULL) build_automaton(p->father);
            pre_p = p;
            //保存上一次的值
            p = p->fail;
        }
        if (p == NULL) p = pre_p;
        else p = p->next[i];
        node->next[i]->fail = p;
        build_automaton(node->next[i]);
    }
    return ;
}

双数组字典树ac自动机-层序实现

结构定义
typedef struct DANode{
    int base,check,fail;
}DANode;
层序实现
int has_child(DANode *trie, int p, int i) {
    return abs(trie[trie[p].base + i].check) == p;
}

//参考ａｃ自动机层序实现
void build_ac(DANode *trie, int cnt) {
    int *queue = (int *)calloc(sizeof(int), cnt + 5);
    int head = 0, tail = 0;
    queue[tail++] = 1;
    while (head < tail) {
        int now = queue[head++];
        for (int i = 0; i < SIZE; i++) {
            if (!has_child(trie, now, i)) continue;
            int p = trie[now].fail;
            while (p && !has_child(trie, p, i)) p = trie[p].fail;
            if (p == 0) p = 1;
            else p = trie[p].base + i;
            trie[trie[now].base + i].fail = p;
            queue[tail++] = trie[now].base + i;
        }
    }
}
匹配过程
int match(DANode *trie, const char *str) {
    int cnt = 0;
    int p = 1, q;
    while (str[0]) {
        while (p && !has_child(trie, p, str[0] - 'a')) p = trie[p].fail;
        if (p == 0) p = 1;
        else p = trie[p].base + str[0] - 'a';
        q = p;
        while (q) {
            cnt += (trie[q].check < 0);
            q = trie[q].fail;
        }
        str++;
    }
    return cnt;
}

双数组字典树ac自动机-递归实现

递归实现
//详情参考ａｃ自动机递归实现推导
// 建立编号为ind节点的孩子的失败指针, 前提是编号为ind的节点失败指针已经建立了
void build_acdfs(DANode *trie,int ind) {
    if(ind == 0) return ;//返回到根节点的失败指针
    if(trie[ind].fail == 0) build_acdfs(trie, abs(trie[ind].check));
    for (int i = 0; i < SIZE; i++) {
        int childind = trie[ind].base + i;
        if (!has_child(trie, ind, i)) continue;
        if (trie[childind].fail) continue;//失败指针已经建立不用再次建立
        int p = trie[ind].fail;
        while (p && !has_child(trie, p, i)) {
            if (trie[p].fail == 0) build_acdfs(trie,abs(trie[p].check));
            p = trie[p].fail;
        }
        if (p == 0) p = 1;
        else p = trie[p].base + i;
        trie[childind].fail = p;
        build_acdfs(trie,childind);
    }
}
完整参考程序
/*************************************************************************
	> File Name: 4.double_arraytree_ac_dfs.cpp
	> Author: ldc
	> Mail: litesla
	> Created Time: 2019年01月23日 星期三 17时45分13秒
 ************************************************************************/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>
#define BASE 'a'
#define SIZE 26

typedef struct Node{
    int flag;
    struct Node *next[SIZE];
}Node;


Node *getNewNode() {
    return (Node *)calloc(sizeof(Node), 1);
}

int insert(Node *node, const char *str) {
    Node *p = node;
    int cnt = 0,ind = 0;
    while (str[0]) {
        ind = str[0] - BASE;
        if (p->next[ind] == NULL) {
            p->next[ind] = getNewNode();
            cnt++;
        }
        p = p->next[ind];
        str++;
    }
    p->flag= 1;
    return cnt;
}
int search(Node *node, const char *str) {
    Node *p = node;
    int ind = 0;
    while (p && str[0]) {
        ind = str[0] - BASE;
        p=p->next[ind];
        str++;
    }
    return (p && p->flag);
}


void clear(Node *node) {
    if (node == NULL) return ;
    for (int i = 0; i < BASE; i++) {
        clear(node->next[i]);
    }
    free(node);
    return ;
}
///
typedef struct DANode{
    int base,check,fail;
}DANode;

DANode *getNewDANode(int n){
    return (DANode *)calloc(sizeof(DANode), n);
}
int get_base(Node *node, DANode *data) {
    int base = 1,flag = 0;
    while (!flag) {
        base++;
        flag = 1;
        for (int i = 0; i < SIZE; i++) {
            if (node->next[i] == NULL) continue;//没有这个儿子节点返回
            if (data[base + i].check == 0) continue;//没有信息返回
            //运行到这一行的条件是,有data[base + i].check 有信息也就是有父亲节点
            //所以我们把flag置为0,当flag位0时表示可以进行下一次循环,然后我们跳出for循环
            //因为已经没有必要继续下去了,以这个base为下标的不能存储所有儿子节点
            flag = 0;
            break;
        }
    }
    return base;
}



void  build(Node *node, DANode * data, int ind) {
    if(node == NULL) return ;
    if (node->flag) data[ind].check = -data[ind].check;
    //表示儿子独立成词
    data[ind].base = get_base(node, data);
    for (int i = 0; i < SIZE; i++) {
        if (node->next[i] == NULL) continue;
        data[data[ind].base + i].check = ind;
        //儿子节点记录父亲节点的下标信息
    }
    for (int i = 0; i < SIZE; i++) {
        if (node->next[i] == NULL) continue;
        build(node->next[i],data,data[ind].base + i);
    }
    return ;
}

int searchD(DANode *data, const char *str) {
    int p = 1;
    for (int i = 0; str[i]; i++) {
        int delta = str[i] - BASE;
        //节点是那个字符的信息
        int check = abs(data[data[p].base + delta].check);
        //儿子节点的父亲
        if (check - p) return 0;
        //如果父亲是这个节点的儿子,则check等于p,if条件位0,
        p = data[p].base + delta;
        //坐标后移
    }
    return data[p].check < 0;
}
int has_child(DANode *trie, int p, int i) {
    return abs(trie[trie[p].base + i].check) == p;
}

void build_ac(DANode *trie, int cnt) {
    int *queue = (int *)calloc(sizeof(int), cnt + 5);
    int head = 0, tail = 0;
    queue[tail++] = 1;
    while (head < tail) {
        int now = queue[head++];
        for (int i = 0; i < SIZE; i++) {
            if (!has_child(trie, now, i)) continue;
            int p = trie[now].fail;
            while (p && !has_child(trie, p, i)) p = trie[p].fail;
            if (p == 0) p = 1;
            else p = trie[p].base + i;
            trie[trie[now].base + i].fail = p;
            queue[tail++] = trie[now].base + i;
        }
    }
}
// 建立编号为ind节点的孩子的失败指针, 前提是编号为ind的节点失败指针已经建立了
void build_acdfs(DANode *trie,int ind) {
    if(ind == 0) return ;//返回到根节点的失败指针
    if(trie[ind].fail == 0) build_acdfs(trie, abs(trie[ind].check));
    for (int i = 0; i < SIZE; i++) {
        int childind = trie[ind].base + i;
        if (!has_child(trie, ind, i)) continue;
        if (trie[childind].fail) continue;//失败指针已经建立不用再次建立
        int p = trie[ind].fail;
        while (p && !has_child(trie, p, i)) {
            if (trie[p].fail == 0) build_acdfs(trie,abs(trie[p].check));
            p = trie[p].fail;
        }
        if (p == 0) p = 1;
        else p = trie[p].base + i;
        trie[childind].fail = p;
        build_acdfs(trie,childind);
    }
}
int match(DANode *trie, const char *str) {
    int cnt = 0;
    int p = 1, q;
    while (str[0]) {
        while (p && !has_child(trie, p, str[0] - 'a')) p = trie[p].fail;
        if (p == 0) p = 1;
        else p = trie[p].base + str[0] - 'a';
        q = p;
        while (q) {
            cnt += (trie[q].check < 0);
            q = trie[q].fail;
        }
        str++;
    }
    return cnt;
}

int main() {
    Node *root = getNewNode();
    int n = 0,cnt1 = 1;
    char str[50];
    scanf("%d", &n);
    for (int i = 0; i < n; i++) {
        scanf("%s", str);
        cnt1 += insert(root,str);
    }
    DANode *trie = getNewDANode(cnt1 * 10);
    build(root,trie,1);
    build_ac(trie, cnt1 * 10);
    //build_acdfs(trie,1);
    while (scanf("%s", str)) {
        printf("search %s = %d\n", str, match(trie, str));
    }
    clear(root);
    return 0;
}
ldc__
关注
专栏目录
KMP算法 字典树 AC自动机（update）
zbbxndm的博客
05-15 274
KMP算法 AC自动机
java编程之AC自动机工作原理与实现代码
08-28
AC自动机的工作原理基于Trie树（字典树），并借鉴了KMP模式匹配算法的核心思想。 1. 应用场景 AC自动机主要应用于多模字符串匹配问题，例如在给定文本串中找出多个目标字符串的出现次数和位置。这种问题在实际应用...
AC自动机算法（Aho-Corasick 多模式匹配算法）
08-18
AC自动机算法（Aho-Corasick 多模式匹配算法）C#实现
自然语言处理hanlp------9基于双数组字典树的AC自动机
iterhuiの博客
02-06 1433
文章目录前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、pandas是什么？ 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。 二、使用步骤 1.引入库 代码如下（示例）： import numpy as np import
双数组字典树（DoubleArrayTrie）
最新发布
xy2006860的专栏
08-06 660
双数组字典树(Double-Array Trie)是一种高效的字符串检索数据结构,它结合了Trie树的快速查找特性和数组的紧凑存储优势。这种数据结构主要用于实现高速字符串匹配,特别适合处理大规模字典和自然语言处理任务。
双数组trie原理
chivalry
05-01 4438
双数 组 Trie(Double-ArrayTrie) 的数据结构是两个整数数组，一个是base[]，一个是check 这个算法的本质就是将Trie树结构简化为两个线性数组，如图2所示。 base数组和数组中的元素是一一对应的，base数组中的每一个元素相当于Trie树的一个节点，其值做状态转移的基值，check值相当于校验值，用于检查该状态是否存在。对于从状态 s到状态t的一个转移，必须满
AC自动机算法
懒猫的脚印
08-15 1321
ac自动机，双数组
结合双数组Trie的AC自动机算法
weixin_34381687的博客
04-07 376
　　结合双数组Trie的AC自动机算法是一种相对比较快的词匹配算法，常见于分词系统用于分词，本文准备用伪代码结合实例的形式来讲解一下该匹配算法的实现原理 构建步骤： 　　1.Trie树的构建 首先直观感受一下Trie树： 插入模式串 ball、bat、doll、dork、dorm、do、send、sense之后形成的trie树 trie树分三步：插入（构建）、查找、删除 ...
字典树实现AC自动机
01-03
接下来，我们将深入探讨AC自动机的工作原理、实现方法以及它与字典树的关系。 **AC自动机的基本概念** AC自动机是由Aho和Corasick在1975年提出的，它的核心思想是构建一个状态机，每个状态代表一个或多个字符串，...
36丨AC自动机：如何用多模式串匹配实现敏感词过滤功能？1
08-03
AC自动机在Trie树的基础上进行了扩展，增加了失败指针，以实现更快速的匹配过程。 首先，我们需要理解Trie树，也被称为前缀树或字典树。Trie树是一种用于存储字符串集合的数据结构，每个节点代表一个前缀，从根节点...
AC自动机_AC自动机模板_
09-30
4. 构建AC自动机：将处理完失败链接的字典树转化为AC自动机，此时每个节点不仅包含了指向子节点的指针，还包含了失败链接和一个“报告”数组，用于记录该节点作为前缀时，所有匹配模式串的信息。 在实际应用AC...
中文分词系列（二） 基于双数组Tire树的AC自动机
weixin_33725126的博客
10-21 350
秉着能偷懒就偷懒的精神，关于AC自动机本来不想看的，但是HanLp的源码中用户自定义词典的识别是用的AC自动机实现的。唉～没办法，还是看看吧 AC自动机理论 Aho Corasick自动机，简称AC自动机，要学会AC自动机，我们必须知道什么是Trie，也就是字典树。Trie树，又称单词查找树或键树，是一种树形结构，是一种哈希树的变种。典型应用是用于统计和排序大量的字符串（但不仅限于字符串...
AC自动机
bbbblzy的博客
12-10 330
背景Aho-Corasick自动机算法（简称AC自动机）1975年产生于贝尔实验室。该算法应用有限自动机巧妙地将字符比较转化为了状态转移。 AC自动机主要用于多关键字的字符串匹配。 要搞懂AC自动机，先得有模式树（字典树）Trie和KMP模式匹配算法的基础知识。 KMP：传送门 Trie：传送门 一个常见的例子就是给出n个单词，再给出一段包含m个字符的文章，让你找出有多少个单词在文章里
AC 自动机的实现(使用双数组 DoubleArray Trie 树)
Gibson314的博客
08-19 394
关于，有太多的文章在讲述它的原理，讲述者借此来展示自己的算法能力。但其实AC自动机的原理很简单，真正困难的地方在于一个高效的！
自然语言处理hanlp------7-1双数组字典树
iterhuiの博客
01-25 789
文章目录前言一、双数组字典树是什么？二、使用步骤1.引入库2.读入数据总结 前言 上一节的BinTrie的接口做到了1000万字每秒的速度，比Python的64万字每秒提高了两个数量级。但我们是算法工程师，要做到挑战极限。 提示：以下是本篇文章正文内容，下面案例可供参考 一、双数组字典树是什么？ 二、使用步骤 1.引入库 代码如下（示例）： import numpy as np import pandas as pd import matplotlib.pyplot as plt import sea
自然语言处理hanlp------7-2双数组字典树（*初学者可选择性学习）
iterhuiの博客
01-30 345
文章目录前言一、构造*二、由图和文字介绍来理解1.图2.分析图逆向理解总结 前言 本章节内容有一定难度，初学者可以选择性学习 我们从晗佬的双数组结构来逆向理解这个流程，就会简单很多。 一、构造* 何晗大佬的书上本节写的特别多，也比较复杂，我讲概述一下，首先，我们要明白双数组字典树是一个深度优先遍历的问题，目的是为字典树的每个节点分偶一个双数组中的下标，并维护双数组的值。构造算法的过程是递归的。 二、由图和文字介绍来理解 1.图 2.分析图 看图：想要分配父节点，就必须先把所有的子节点分配完成..
AC自动机详解及实现
huoji555的博客
04-10 2608
1.背景 之前的Trie树，DBTrie都属于前缀树，虽然DAT每次状态转移的时间复杂度都是常数，但全切分长度为n的文本时，时间复杂度为O(n2)。这是因为**扫描过程中需要不断的挪动起点，发起新的查询**。所以说，DAT的全切分复杂度为O(n2)。 2.为什么需要AC自动机 显然，前缀树的短板是扫描，查询一个句子时，前缀树需要不断的挪动起点，发起新查询，这个过程浪费了大量时间。 举个栗子，扫描...
AC算法结合双数组trie树优化关键词匹配与替换
nzgry_csdn的博客
12-25 1367
AC算法结合双数组trie树优化关键词匹配与替换 参考文章和项目： Aho-Corasick算法的Java实现与分析 双数组Trie树(DoubleArrayTrie)Java实现 Aho Corasick自动机结合DoubleArrayTrie极速多模式匹配 github项目：AhoCorasickDoubleArrayTrie 目录AC算法结合双数组trie树优化关键词匹配与替换trie树Aho-Corasick算法双数组trie树使用原理应用扩展build方法扩展匹配方法使用 trie树 trie
算法与数据结构进阶课第十三节笔记
yshuoo的博客
05-28 418
AC自动机与卡特兰数 AC自动机 1）关键在于fail指针的理解（网上帖子几乎没有解释） fail指针含义：目前来到的节点，之前路径上的字符串记为str，除了str之外哪个前缀字符串，和str的后缀串匹配最大，fail指针就指向那个最大匹配串的最后字符底下的节点。（难理解吧？其实是精髓，看视频） 2）构建和使用看视频 ...
python 用pyhanlp实现基于双数组字典树的ac自动机
04-04
下面是使用PyHanLP实现基于双数组字典树的AC自动机的示例代码： ```python from pyhanlp import * class ACAutomaton: def __init__(self): self.base = [] self.check = [] self.keyword_map = {} def ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值