AC自动机训练(16.04.01)

最新推荐文章于 2022-12-08 10:06:56 发布
最新推荐文章于 2022-12-08 10:06:56 发布
阅读量634 收藏 1
点赞数
分类专栏： algorithm_字符串 文章标签： string AC自动机 病毒
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/thearcticocean/article/details/51037981
版权

复习了AC自动机，记录几题，虽然有些之前做过，但是这次又写了一遍后感觉有了新的认识（以前写的不好的直接删除了 ^_^）。外加一道和AC自动机没有半毛钱关系的模拟题。
hdu 2222 Keywords Search
hdu 2896 病毒侵袭
zoj 3228 Searching the String
hdu 2778 LCR (模拟题）

http://acm.hdu.edu.cn/showproblem.php?pid=2222
大意：找出字符串中包含几个关键字
分析：简单AC自动机，再写一次此题是因为这次注释写的比以往详细^_^。

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
const int N=1e6+10;
struct node{
    int sum;
    node *fail,*next[26];
    node(){
        sum=0;
        fail=NULL;
        for(int i=0;i<26;i++) next[i]=NULL;
    }
};
node *root;
void w_insert(char str[]){
    node *p=root;
    for(int i=0;str[i];i++){
        int dex=str[i]-'a';
        if(p->next[dex]==NULL){
            p->next[dex]=new node();
        }
        p=p->next[dex];
    }
    p->sum++;  //记录字符串的个数
}
node *que[N];  //指针数组
void fail_point(){
    int head=0,tail=0;
    que[tail++]=root;
    while(head<tail){
        node *p=que[head++], *temp=NULL;
        for(int i=0;i<26;i++){
            if(p->next[i]){
                if(p==root) p->next[i]->fail=root;  // 第一个字符就不匹配
                else {
                    temp=p->fail;  // 上一个结点
                    while(temp){
                        if(temp->next[i]){
                           p->next[i]->fail=temp->next[i]; //失败指针指向相同字符
                           break;
                        }
                        temp=temp->fail;  //不断找到和上个字符一样的结点
                    }
                    if(temp==NULL) p->next[i]->fail=root;  //找不到用结点
                }
                que[tail++]=p->next[i];  //入队
            }
        }
    }
}
int query(char *s){  //查询模式串（短串）的个数
    int ans=0;
    node *p=root;
    for(int i=0;s[i];i++){
        int dex=s[i]-'a';
        while(p!=root && p->next[dex]==NULL) p=p->fail;  // 找到适合点，防止非法内存的访问
        p=p->next[dex];
        if(p==NULL) p=root;  // 经过所有的相同前缀，始终找不到
        node *temp=p;  // 防止乱了
        while(temp!=root && temp->sum!=-1){ // fail的极限是root
            ans+=temp->sum;   // 设-1是判断条件, 0依然可以是可能串的前缀
            temp->sum=-1;
            temp=temp->fail;
        }
    }
    return ans;
}
char s[55],str[N];
int main()
{
    //freopen("cin.txt","r",stdin);
    int t,n;
    cin>>t;
    while(t--){
        root=new node();  //开辟新地址
        scanf("%d",&n);
        for(int i=0;i<n;i++){
            scanf("%s",s);
            w_insert(s);
        }
        fail_point();
        scanf("%s",str);
        printf("%d\n",query(str));
    }
    return 0;
}

hdu 2896 病毒侵袭

http://acm.hdu.edu.cn/showproblem.php?pid=2896
大意：
……
第一行，一个整数N（1<=N<=500），表示病毒特征码的个数。
接下来N行，每行表示一个病毒特征码，特征码字符串长度在20―200之间。
每个病毒都有一个编号，依此为1―N。
不同编号的病毒特征码不会相同。
在这之后一行，有一个整数M（1<=M<=1000），表示网站数。
接下来M行，每行表示一个网站源码，源码字符串长度在7000―10000之间。
每个网站都有一个编号，依此为1―M。
以上字符串中字符都是ASCII码可见字符（不包括回车）。
分析：
ASCII可见字符：32-126（95个，其中32是空格）

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int N=100, M=1e5+10; 
struct node{
    int id;
    node *next[N],*fail;
    node(){
        id=0;
        fail=NULL;
        memset(next,0,sizeof(next));
    }
};
node *root;
void w_insert(char *s,int dex){
    node *p=root;
    for(int i=0;s[i];i++){
        int d=s[i]-32;
        if(p->next[d]==NULL) p->next[d]=new node();
        p=p->next[d];
    }
    p->id=dex; 
}
node *que[M];
void fail_point(){
    int head=0,tail=0;
    que[tail++]=root;
    while(head<tail){
        node *p=que[head++], *temp=NULL;
        for(int i=0;i<N;i++){
            if(p->next[i]){
                if(p==root) p->next[i]->fail=root;
                else {
                    temp=p->fail;
                    while(temp){
                        if(temp->next[i]){
                            p->next[i]->fail=temp->next[i];
                            break;
                        }
                        temp=temp->fail;
                    }
                    if(temp==NULL) p->next[i]->fail=root; 
                }
                que[tail++]=p->next[i];
            }
        }
    }
}
int web[505],top;
bool tag[505];
void query(char *s){
    top=0;
    memset(tag,0,sizeof(tag));
    node *p=root;
    for(int i=0;s[i];i++){
        int d=s[i]-32;
        while(p!=root && p->next[d]==NULL) p=p->fail;
        p=p->next[d];
        if(p==NULL) p=root;
        node *temp=p;
        while(temp!=root){
           if(tag[temp->id]==0 && temp->id){
               web[top++]=temp->id;
               tag[temp->id]=1; 
            }
            temp=temp->fail;
        }
    }
}
char s[205],str[10010];
int main()
{
    //freopen("cin.txt","r",stdin);
    int n,m;
    while(cin>>n){
        root=new node();
        for(int i=1;i<=n;i++) {
            scanf("%s",s);
            w_insert(s,i);
        }
        fail_point();
        scanf("%d",&m);
        int total=0;
        for(int i=1;i<=m;i++){
            scanf("%s",str);
            query(str);
            sort(web,web+top);  // virus order arise
            if(top){
                total++;
                printf("web %d: ",i);
                for(int j=0;j<top-1;j++) printf("%d ",web[j]);
                printf("%d\n",web[top-1]);
            }
        }
        printf("total: %d\n",total);
        delete root;
    }
    return 0;
}

zoj 3228 Searching the String

http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemId=3441
大意：给出一些短串，求得在长串中有多少的特征短串。如果标志值tag是0，则允许在长串中相同短串重叠统计，如果tag是1则不允许。
分析：和一般的多串匹配相比这题的难点在于有时可以重叠统计，有时又不允许重叠统计。题目最开始给出长串，可能一开始向这样的方向思考：把所有的特征短串写入trie树，然后AC自动机模式匹配。恩，成功的走向了死胡同。因为用长串来查找统计短串的个数很有可能一开始就得到0。 正确的思路是把长串上所有的子串都放进trie树，然后拿每一个短串来匹配统计自身在长串中出现的次数。我们在插入特征短串的时候就记录所有字符的overlap和not overlap的结果。最后根据tag直接找到短串输出即可。
hit: 使用STL queue可以防止MLE。
<此题之前也写过：http://blog.csdn.net/thearcticocean/article/details/47165197>

#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>
using namespace std;
const int N=26,M=6e5+10;
char s[10],str[100010];
struct node{
    int id,tag[2];
    node *next[N],*fail;
    node(){
        id=-1;
        tag[0]=tag[1]=0;
        fail=NULL;
        memset(next,0,sizeof(next));
    }
};
node *root;
void w_insert(int dex){
    node *p=root;
    for(int i=dex;i<dex+6 && str[i];i++){
        int d=str[i]-'a';
        if(p->next[d]==NULL) p->next[d]=new node();
        p=p->next[d];
        p->tag[0]++; // allow overlap 
        if(p->id<dex) { // not alow overlap, from front to back 
            p->tag[1]++;
            p->id=i;
        }
    }
}
//node *que[M];
queue<node *> que;
void fail_build(){
    while(!que.empty()) que.pop();
    //int head=0,tail=0;
    //que[tail++]=root;
    que.push(root);
    while(!que.empty()){
        node *p=que.front(), *temp=NULL;
        que.pop();
        for(int i=0;i<N;i++){
            if(p->next[i]){
                 if(p==root) p->next[i]->fail=root;
                 else {
                      temp=p->fail;
                      while(temp){
                         if(temp->next[i]){
                             p->next[i]->fail=temp->next[i]; 
                             break; 
                          }
                          temp=temp->fail;
                      }
                      if(temp==NULL) p->next[i]->fail=root;
                  }
                  que.push(p->next[i]);
             }
        }
    }
}
int query(int t){
    node *p=root;
    for(int i=0;s[i];i++){
        int d=s[i]-'a';
        while(p->next[d]==NULL) return 0;
        p=p->next[d];
    }
    return p->tag[t];
}
void del(node *p){  
     if(p==NULL)return ;  
     for(int i=0;i<N;i++)del(p->next[i]);  
     delete p;  
}  
int main(){
    //freopen("cin","r",stdin);
    int n,t;
    int ca=1;
    while(~scanf("%s",str)){
        root=new node();
        for(int i=0;str[i];i++) w_insert(i); // enter every one word 
        fail_build();
        scanf("%d",&n);
        printf("Case %d\n",ca++);
        for(int i=0;i<n;i++){
            scanf("%d%s",&t,s);
            printf("%d\n",query(t));
        }
        puts("");
        del(root);
    }
    return 0;
}

hdu 2778 LCR （模拟题）

http://acm.hdu.edu.cn/showproblem.php?pid=2778
大意：多个人玩一个游戏，一开始所有的人都有3个chips，从第一个人开始执筛子，最多执3次，如果chips少于3那就执chips次。面是L，将自己的一个chip交给左边的人，i+1那个人；面是R，将自己的一个chips交给右边的人，i-1那个人;面是C，将自己的一个chip放到center中。如果一个人拥有了除center里的所有chips，那么他就赢了，游戏结束，即使字符串没有读完也结束。如果字符串剩下的字符不足以进行投筛子那么也结束
分析：模拟求之

#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
const int N=1e6+10;
char s[N];
int f[13],center;
int check(int n){
    int over=0;
    for(int i=0;i<n;i++) if(f[i]) over++;
    return over;
}
int main(){
    //freopen("cin.txt","r",stdin);
    int n,ca=0;
    while(cin>>n&&n){
        scanf("%s",s);
        for(int i=0;i<n;i++) f[i]=3;
            center=0;
            int p=0,temp=0,L=strlen(s);
            int over,i;
            for(i=0;s[i];){
            over=check(n);
            if(over==1) break; 
            temp=f[p];
            if(temp>3) temp=3;  // 最多执三次
            if(temp>L-i) break;
            while(temp && s[i]){
                if(s[i]=='L'){ f[(p+1)%n]++; f[p]--; }
                else if(s[i]=='R'){  f[(p-1+n)%n]++; f[p]--; }
                else if(s[i]=='C'){  center++; f[p]--; }
                temp--;  i++;
                over=check(n);
                if(over==1) break; 
            }
            if(over==1) break;
            p=(p+1)%n;
        }
        while(over>1 && f[p]==0) p=(p+1)%n;  // 找到下一个人
        if(ca) puts(""); 
        printf("Game %d:\n",++ca);
        for(int i=0;i<n;i++){
            if(over==1) {
                if(f[i]) printf("Player %d:%d(W)\n",i+1,f[i]);
                else printf("Player %d:0\n",i+1);
            }
            else {
                if(i==p) printf("Player %d:%d(*)\n",i+1,f[i]);
                else printf("Player %d:%d\n",i+1,f[i]);
            }
        }
        printf("Center:%d\n",center); 
    }
    return 0;
}
theArcticOcean
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
AC自动机_AC自动机模板_
09-30
供信息学奥林匹克竞赛选手使用 AC自动机模板
AC自动机
qq_45832461的博客
08-09 864
AC自动机 AC自动机的作用：给定一段包含mmm个字符的文章，再给定nnn个单词，找出有多少个单词在文章里面出现过。 AC自动机实际上是先将KMP算法和Trie字典树结合，用多个模式串构建一棵字典树，然后在这棵字典树上构建失配指针，失配指针相当于KMP算法中的next[]数组（匹配失败时的回退位置），最后将主串在Trie树上进行模式匹配。 AC自动机算法分为3步： 构建一棵字典树 构建AC自动机 进行模式匹配 这里主要讲解如何构建AC自动机和如何进行模式匹配。 构建AC自动机 在构建AC自动机时，其
ac自动机
清风拂面
03-24 687
AC自动机，是Aho-Corasick automaton的简称，该算法在1975年产生于贝尔实验室，是著名的多模匹配算法。AC自动机是对字典树算法的一种延伸，是字符串中运用非常广泛的一种算法； AC自动机比字典树Trie多维护一个数组——fail数组。fail数组的作用是指向当前节点表示的字符串的后缀可以和模式串匹配上的最大长度的节点。是不是和KMP的next数组有点相似？ KMP的next数组是自己和自己的匹配，而AC自动机的fail数组是自己和模式串(当然也包括自己)的匹配。 比如：我们有字典.
字符串处理【AC自动机】 - 原理 AC自动机详解
谢谢你们的关注
12-08 1169
字符串处理【AC自动机】 - 原理 AC自动机详解
java ac自动机_ac自动机java版
weixin_35952929的博客
02-23 312
【实例简介】从别的共享资源下载的java版ac自动机，已验证使用非常好。【实例截图】【核心代码】ahocorasick_java-1.1└── ahocorasick_java-1.1├── ahocorasick│ ├── pom.xml│ ├── src│ │ └── main│ │ └── java│ │ └── org│ │ ...
AC自动机算法
懒猫的脚印
08-15 1262
ac自动机，双数组
ac自动机.pptx
07-14
要学AC自动机需要自备两个前置技能:KMP和trie树(其实个人感觉不会kmp也行,失配指针的概念并不难) 其中,KMP是用于一对一的字符串匹配,而trie虽然能用于多模式匹配,但是每次匹配失败都需要进行回溯,如果模式串很长的话...
中文高性能AC自动机代码
11-05
C语言实现，效率极高，实现了中文的关键字匹配，输出的格式为偏移量加上关键字（中文编码为GB2312）
经典AC自动机.cpp
08-19
ac自动机,就是在tire树的基础上,增加一个fail指针,如果当前点匹配失败,则将指针转移到fail指针指向的地方,这样就不用回溯,而可以路匹配下去了
algorithm 题集三 (16.05.24)
theArcticOcean
05-24 5442
练习的故事仍然继续下去，今天写下的题目难度适中，记录自己近段时间的训练成果。涉及数学，动态规划，字符串问题。poj 2159 Ancient Cipher(规律)http://poj.org/problem?id=2159 大意：密码加密方法，两种加密方式，第一种，替换加密：Substitution cipher changes all occurrences of each letter to
hdu 1075 What Are You Talking About (字典树·文字翻译)
theArcticOcean
08-12 1026
题目：http://acm.hdu.edu.cn/showproblem.php?pid=1075 Description Ignatius is so lucky that he met a Martian yesterday. But he didn't know the language the Martians use. The Martian gives him a
后缀数组学习
theArcticOcean
05-07 949
相关学习资料：《后缀数组——处理字符串的有力工具》、《后缀树》(http://wenku.baidu.com/link?url=c5DBWJ9b6UNTzV6uxvQZuPerd4FSOWFWpt8ekWcsgyLXT7LZcy4aKlpI5QZ5fdO8SIGqQDVPlXmIBnbRur0ZWHpmvYTJvmC_r8KWoQ-LWxq)后缀数组SA： 保存1..n 的某个排列SA[1]，SA[
hdu 1671 Phone List(字典树·粉刷式标记)
theArcticOcean
08-12 884
题目：http://acm.hdu.edu.cn/showproblem.php?pid=1671 Description Given a list of phone numbers, determine if it is consistent in the sense that no number is the prefix of another. Let’s say the
manacher练习 (16.04.23)
theArcticOcean
04-23 817
继续上次的故事，又做了三道回文字符串的题，记录下来，当然他们不是都非得用manacher，使用KMP也能解决。hdu 3068 最长回文http://acm.hdu.edu.cn/showproblem.php?pid=3068 大意：求出求出最长回文子串的长度 分析：简单模板题code: #include <iostream> #include <cstdio> #include <cstri
KMP训练五题
theArcticOcean
03-25 801
再次学习KMP，关于字符串的许多东西快忘光了，惭愧。这次训练5道题，分别是： hdu 3336 Count the string （理解） hdu 4763 Theme Section （理解） hdu 2594 Simpson’s Hidden Talents （合并串） hdu 3746 Cyclic Nacklace （最小循环节） zoj 3587 Marlon’s String
hdu 1800 Flying to the Mars（字典树||map||hash）
theArcticOcean
07-13 761
题目：http://acm.hdu.edu.cn/showproblem.php?pid=1800 给出一堆士兵的等级，等级高的的士兵可以当等级小的士兵的师傅，一个士兵最多一个师傅（可以没有），一个师傅最多1个徒弟（可以没有），如果是师徒关系，可以用一把扫帚练习技能，问：全部士兵都用扫帚练习时需要的最少的扫帚数量？ 这就是寻找一棵树的最大分支嘛，如果所有的数字均不相同那么必能连成一串，仅需
AC自动机初识&hdu 2222 Keywords Search
theArcticOcean
07-30 749
AC自动机：Aho-Corasick automaton，该算法在1975年产生于贝尔实验室，是著名的多模匹配算法之一。 AC自动机的核心：字典树（trie树），KMP模式匹配算法，BFS（因为是多模匹配）。首先构造一颗trie树，再在trie树上制作fail指针（用到了temp指针尝试是否fail），有了这样的数据结构作为基础后就能用KMP算法的思想来查找目标串。最后用BFS来统计匹配的串的个
hdu 3065 病毒侵袭持续中（AC automaton)
theArcticOcean
07-30 704
题目：http://acm.hdu.edu.cn/showproblem.php?pid=3065 每个子串是不同的，求出在源码串中各个子串出现的次数，按照输入子串的顺序将出现次数大于0的输出。 例如： Sample Input 3 AA BB CC ooxxCC%dAAAoen....END   Sample Output AA: 2 CC: 1 Hin
python ac自动机
最新发布
09-02
Python AC自动机是一个用于字符串匹配的算法，它可以高效地在一段文本中查找多个预定义的模式。它的实现可以使用多种库，其中包括ac自动机python和ahocorasick-python。 ac自动机python是一个对标准的ac自动机算法...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值