Trie树，AC自动机模版

于 2013-01-05 18:41:58 发布
阅读量790 收藏
点赞数
分类专栏： 字符串处理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/byijie/article/details/8470333
版权

自己写的模板，请大家指错...Trie树模板用hdu1075试了，AC自动机用hdu2222试了。

下面是动态的Trie树和AC自动机 （静态的放假再补上，顺便复习...）

Trie树：

//Trie树的简单实现（动态）
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
#define maxc 26 //26小写英文字符trie树 
struct node
{
    bool is;
    char ch;
    node* child[maxc];
};
node* ROOT;
int CtoI(char c) //将字符转换成下标 
{
    return c-'a';
}
void Init()
{
    int i;
    ROOT=new node();
    ROOT->is=0;
    ROOT->ch=' ';
    for(i=0;i<maxc;++i)
        ROOT->child[i]=NULL;
}
node* CreateNode(char c)
{
    int i;
    node *t=new node();
    t->is=false;
    t->ch=c;
    for(i=0;i<maxc;++i)
        t->child[i]=NULL;
    return t;
}
void Insert(char chars[],int len)
{  
    int i,index;
    node* t=ROOT;
    char c;
    for(i=0;i<len;++i)
    {
        c=chars[i];
        index=CtoI(c);
        if(t->child[index]==NULL)
            t->child[index]=CreateNode(c);
        t=t->child[index];
    }
    t->is=true;
}
bool Find(char chars[],int len)
{
    int i,index;
    node* t=ROOT;
    char c;
    for(i=0;i<len;++i)
    {
        c=chars[i];
        index=CtoI(c);
        if(t->child[index]==NULL)
            break;
        t=t->child[index];
    }
    if(i==len&&t->is==true)
        return true;
    else
        return false;
}
void DeleteTrie(node *t)
{
    int i;
    for(i=0;i<maxc;++i)
    {
        if(t->child[i]!=NULL)
            DeleteTrie(t->child[i]);
    }
    delete t;
}
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
#define maxc 26
struct Node
{
    bool is;
    char ch;
    Node *child[maxc];
    Node ()
    {
        is=false;
        ch=' ';
        for(int i=0;i<maxc;++i)
            child[i]=NULL;
    }
    Node (char c)
    {
        is=false;
        ch=c;
        for(int i=0;i<maxc;++i)
            child[i]=NULL;
    }
};
Node *Root;
void Init()
{
    Root=new Node();
}
void Insert(char chs[])
{
    int i,id,len=strlen(chs);
    Node *t=Root;
    char c;
    for(i=0;i<len;++i)
    {
        c=chs[i];
        id=c-'a';
        if(t->child[id]==NULL)
            t->child[id]=new Node(c);
        t=t->child[id];
    }
    t->is=true;
}
bool Find(char chs[])
{
    int i,id,len=strlen(chs);
    Node *t=Root;
    char c;
    for(i=0;i<len;++i)
    {
        c=chs[i];
        id=c-'a';
        if(t->child[id]==NULL)
            break;
        t=t->child[id];
    }
    if(i==len&&t->is==true)
        return true;
    else
        return false;
}
void DeleteTrie(Node *t)
{
    int i;
    for(i=0;i<maxc;++i)
    {
        if(t->child[i]!=NULL)
            DeleteTrie(t->child[i]);
    }
    delete t;
}


 

AC自动机：

//Aho-Corasick automation(动态)
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<queue>
using namespace std;
#define maxc 26
struct node
{
    char ch;
    bool IsStr;           //int count
    node *child[maxc];
    node *fail;
};
node *ROOT;
int CtoI(char c)
{
    return c-'a';
}
void Init()
{
    int i;
    ROOT=new node();
    ROOT->ch=' ';
    ROOT->IsStr=false;
    for(i=0;i<maxc;++i)
        ROOT->child[i]=NULL;
    ROOT->fail=NULL;
}
node* CreateNode(char c)
{
    int i;
    node *t=new node();
    t->ch=c;
    t->IsStr=false;
    for(i=0;i<maxc;++i)
        t->child[i]=NULL;
    t->fail=NULL;
    return t;
}
void Insert(char chars[])
{
    int i,index,len=strlen(chars);
    char c;
    node *t=ROOT;
    for(i=0;i<len;++i)
    {
        c=chars[i];
        index=CtoI(c);
        if(t->child[index]==NULL)
            t->child[index]=CreateNode(c);
        t=t->child[index];
    }
    t->IsStr=true;
}
void DeleteTrie(node *t)
{
    int i;
    for(i=0;i<maxc;++i)
    {
        if(t->child[i]!=NULL)
            DeleteTrie(t->child[i]);
    }
    delete t;
}
void PreAC()
{
    queue<node*> q;
    q.push(ROOT);
    int i;
    node *p,*t;
    while(!q.empty())
    {
        p=q.front();
        q.pop();
        for(i=0;i<maxc;++i)
        {
            if(p->child[i]!=NULL)
            {
                t=p->fail;
                while(t!=NULL&&t->child[i]==NULL)
                    t=t->fail;
                if(t==NULL)
                    p->child[i]->fail=ROOT;
                else
                    p->child[i]->fail=t->child[i];
                q.push(p->child[i]);
            }
        }
    }
}
int Find(char* T)
{
    int i,index,ans=0,len=strlen(T);
    node *p,*t;
    p=ROOT;
    char c;
    for(i=0;i<len;++i)
    {
        c=T[i];
        index=CtoI(c);
        while(p!=NULL&&p->child[index]==NULL)
            p=p->fail;
        if(p==NULL)
            p=ROOT;
        else
        {
            p=p->child[index];
            t=p;
            while(t!=NULL)              //t!=NULL&&count!=-1
            {
                if(t->IsStr)
                    ans++;
                t=t->fail;
            }
        }
    }
    return ans;
}


 附hdu1075，hdu2222代码：

1075：

//Trie树的简单实现（动态）
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
#define maxc 26 //26小写英文字符trie树 
struct node
{
    bool is;
    char *value;
    node* child[maxc];
};
node* ROOT;
int CtoI(char c) //将字符转换成下标 
{
    return c-'a';
}
void Init()
{
    int i;
    ROOT=new node();
    ROOT->is=0;
    ROOT->value=NULL;
    for(i=0;i<maxc;++i)
        ROOT->child[i]=NULL;
}
node* CreateNode()
{
    int i;
    node *t=new node();
    t->is=false;
    t->value=NULL;
    for(i=0;i<maxc;++i)
        t->child[i]=NULL;
    return t;
}
void Insert(char english[],char martin[])
{  
    int i,index;
    node* t=ROOT;
    char c;
    for(i=0;i<strlen(martin);++i)
    {
        c=martin[i];
        index=CtoI(c);
        if(t->child[index]==NULL)
            t->child[index]=CreateNode();
        t=t->child[index];
    }
    t->is=true;
    t->value=new char[strlen(english)+1];
    strcpy(t->value,english);
}
const char* Find(char martin[])
{
    int i,index;
    node* t=ROOT;
    char c;
    for(i=0;i<strlen(martin);++i)
    {
        c=martin[i];
        index=CtoI(c);
        if(t->child[index]==NULL)
            break;
        t=t->child[index];
    }
    if(i==strlen(martin)&&t->is==true)
    {
        return t->value;
    }
    else
        return NULL;
}
void DeleteTrie(node *t)
{
    int i;
    for(i=0;i<maxc;++i)
    {
        if(t->child[i]!=NULL)
            DeleteTrie(t->child[i]);
    }
    delete t;
}
int main()
{
    Init();
    char english[15],martin[15];
    int cnt;
    char ch;
    const char *t;
    scanf("%s",english);
    getchar();
    cnt=0;
    while(scanf("%s",english)&&english[0]!='E')
    {
        scanf("%s",martin);
        Insert(english,martin);
    }
    scanf("%s",english);
    getchar();
    while((ch=getchar())!='E')
    {
        if(ch>='a'&&ch<='z')
            martin[cnt++]=ch;
        else
        {
            if(cnt)
            {
                martin[cnt]='\0';
                t=Find(martin);
                if(t!=NULL)
                    printf("%s",t);
                else
                    printf("%s",martin);
            }
            cnt=0;
            putchar(ch);
        }
    }
    getchar();
    getchar();
    return 0;
}


 

2222：

//Aho-Corasick automation(动态)
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<queue>
using namespace std;
#define maxc 26
struct node
{
    char ch;
    int IsStr;
    node *child[maxc];
    node *fail;
}*q[500001];
node *ROOT;
int CtoI(char c)
{
    return c-'a';
}
void Init()
{
    int i;
    ROOT=new node();
    ROOT->ch=' ';
    ROOT->IsStr=0;
    for(i=0;i<maxc;++i)
        ROOT->child[i]=NULL;
    ROOT->fail=NULL;
}
node* CreateNode(char c)
{
    int i;
    node *t=new node();
    t->ch=c;
    t->IsStr=0;
    for(i=0;i<maxc;++i)
        t->child[i]=NULL;
    t->fail=NULL;
    return t;
}
void Insert(char chars[])
{
    int i,index,l=strlen(chars);
    char c;
    node *t=ROOT;
    for(i=0;i<l;++i)
    {
        c=chars[i];
        index=CtoI(c);
        if(t->child[index]==NULL)
            t->child[index]=CreateNode(c);
        t=t->child[index];
    }
    t->IsStr++;
}
void DeleteTrie(node *t)
{
    int i;
    for(i=0;i<maxc;++i)
    {
        if(t->child[i]!=NULL)
            DeleteTrie(t->child[i]);
    }
    delete t;
}
void PreAC()
{
//    queue<node*> q;
    int head=0,tail=0;
//    q.push(ROOT);
    q[tail++]=ROOT;
    int i;
    node *p,*t;
    while(head!=tail)
    {
//        p=q.front();
        p=q[head++];
//        q.pop();
        for(i=0;i<maxc;++i)
        {
            if(p->child[i]!=NULL)
            {
                t=p->fail;
                while(t!=NULL&&t->child[i]==NULL)
                    t=t->fail;
                if(t==NULL)
                    p->child[i]->fail=ROOT;
                else
                    p->child[i]->fail=t->child[i];
//                q.push(p->child[i]);
                q[tail++]=p->child[i];
            }
        }
    }
}
int Find(char* T)
{
    int i,index,ans=0,l=strlen(T);
    node *p,*t;
    p=ROOT;
    char c;
    for(i=0;i<l;++i)
    {
        c=T[i];
        index=CtoI(c);
        while(p!=NULL&&p->child[index]==NULL)
            p=p->fail;
        if(p==NULL)
            p=ROOT;
        else
        {
            p=p->child[index];
            t=p;
            while(t!=NULL&&t->IsStr!=-1)
            {
                ans+=t->IsStr;
                t->IsStr=-1;
                t=t->fail;
            }
        }
    }
    return ans;
}
int main()
{
    char T[1000005],K[55];
    int C,N,ans;
    scanf("%d",&C);
    while(C--)
    {
        scanf("%d",&N);
        Init();
        while(N--)
        {
            scanf("%s",K);
            Insert(K);
        }
        PreAC();
        scanf("%s",T);
        ans=Find(T);
        printf("%d\n",ans);
        DeleteTrie(ROOT);
    }
//    system("pause");
    return 0;
}


 

byijie
关注
专栏目录
AC自动机_AC自动机模板_
09-30
AC自动机的核心思想是将所有模式串构建为一棵树，这棵树被称为“失败链接树”或“AC树”。在AC树中，每个节点对应一个前缀字符串，从根节点到某个节点的路径上的边代表了路径上所有节点对应的字符串连接。当在输入...
AC自动机模板
12-08
**AC自动机（Aho-Corasick Algorithm）模板** AC自动机是一种字符串搜索算法，它在文本中查找多个模式串的出现情况。该算法由艾伦·科拉斯和戈登·科拉斯在1975年提出，是KMP算法和后缀自动机的结合，具有高效性和...
浅谈AC自动机 个人模板与说明
01-03
在下曾学习于 AC自动机详细讲解 必备技能： trie + KMP 文章目录1. 结构体2. 添加模式串3. 求失配指针4. 匹配文本串ends：模板1 统计出现的模式串个数ends：模板2 统计出现次数最多的模式串（带初始化）ends：模板3 ...
java编程之AC自动机工作原理与实现代码
08-28
AC自动机的基础是Trie树，但与Trie树不同的是，每个结点除了有指向孩子的指针，还有一个fail指针，它表示输入的字符与当前结点的所有孩子结点都不匹配时，自动机的状态应转移到的状态。 fail指针的功能可以类比于...
C++常用算法模板.pdf
最新发布
03-11
这些代码片段展示了四种不同的字符串处理算法在C++中的实现，分别是KMP算法、Trie树、Karp-Rabin算法和AC自动机。下面将分别解释这些算法以及它们在给定代码中的应用。 1. KMP算法： KMP（Knuth-Morris-Pratt）算法...
杭电acm ac代码
04-12
2. **高级数据结构**：如二叉堆、斐波那契堆、平衡树（AVL、红黑树等）、字典树（Trie）、后缀数组、后缀自动机等。 3. **字符串处理**：KMP匹配、Manacher算法、Z算法等，用于处理字符串查找和操作。 4. **数学...
C++常用算法模板.docx
03-11
在本文中，我们将讨论四种不同的字符串处理算法，它们是KMP算法、Trie树、Karp-Rabin算法和AC自动机。这些算法在计算机科学，特别是字符串匹配和搜索问题中有着广泛的应用。 首先，KMP（Knuth-Morris-Pratt）算法是...
C++键树编程
04-20
同时，键树可以用于实现AC自动机（Aho-Corasick自动机），这在文本搜索和模式匹配中有广泛应用。 总的来说，C++键树编程是一项涉及数据结构、算法和对象导向编程的重要技能。理解并熟练掌握键树的原理和实现，对于...
ACM算法模板.pdf
12-12
包括KMP算法及其拓展、字典树（Trie）、AC自动机等。这些算法在处理字符串匹配问题上非常高效，是很多搜索引擎和文本处理软件的基础。 12. 树状数组（Binary Indexed Tree）与线段树： 这两种数据结构用于高效地...
acm-icpc模板
05-02
字典树也称为 Trie 树，是一种树形结构，用于高效存储和检索字符串。 ##### Splay Splay 树是一种自平衡的二叉查找树，它的操作性能平均情况下较好，适合频繁访问某些节点的应用场景。 ##### ST 表 & 分块树 ST 表...
ACM模板-Anoyer.pdf
08-04
6. AC自动机和trie树用于处理多模式串匹配问题。 7. 字符串Hash用于快速比较字符串的相似度。 8. Sunday算法是一种基于模式串和文本串的匹配算法。 9. 后缀数组和后缀自动机用于解决字符串的高级处理问题。 10. 最大...
NOIP模板1.zip
05-12
3. **AC自动机.cpp**：AC自动机是一种字符串搜索算法，基于有限状态自动机的概念，能高效地处理大量模式串的匹配问题。在文本处理、信息检索等领域有广泛应用。 4. **Trie字典树.cpp**：Trie（字典树或前缀树）是一...
信息学奥赛各大算法模板
09-03
- **AC自动机**：Aho-Corasick自动机，用于高效地进行字符串模式匹配，一次构建后可以快速查找多个模式串是否出现在文本中。 5. **区间修改算法**：如线段树，是一种数据结构，支持对某一区间的元素进行修改，并能...
foreverzeus大木板 acm模板
12-13
#### 3.3 AC自动机 - **定义**: 多模式字符串匹配算法，可以同时搜索多个模式串。 - **应用场景**: 模式匹配、文本处理等。 #### 3.4 KMP - **定义**: Knuth-Morris-Pratt算法，一种高效的单模式字符串匹配算法。 -...
算法模板.pdf
07-31
- AC自动机：一种用于多模式匹配的字符串搜索算法。 6. 线段树 - 线段树是一种可用于存储区间或线段的树形数据结构，支持快速查询。 - 点更新：线段树中的一种更新方式，即更新单个点的数据。 - 区间更新：线段树中...
ACM算法模板和pku代码
11-09
本科参加ACM竞赛的过程中积累下来的一部分算法模板，和自己在PKU上面做的一部分题目。 模板目录结构： 目录: 动态规划 O(n^2)的最长上升子序列 nlogn最长上升子序列 高精度 ... AC自动机实现多串匹配
ACM模板byXYM
06-16
#### 4.5 AC自动机 用于模式匹配。 #### 4.6 公共祖先和区间极值 涉及LCA算法和RMQ问题。 #### 4.7 Dancing Link 用于解决精确覆盖问题。 ### 五、计算几何 计算几何部分涉及了众多几何对象的定义、性质和算法：...
ACM算法模板集史上最完整收藏版
02-11
25. **AC自动机**： - 结合了字典树和KMP算法的优点。 - 在模式匹配问题中非常高效。 26. **FFT（快速傅里叶变换）**： - 用于快速计算多项式的乘法。 - 在信号处理和编码理论中有着广泛应用。 27. **二分图...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值