HDU 2222 AC自动机

最新推荐文章于 2021-07-27 01:09:57 发布
最新推荐文章于 2021-07-27 01:09:57 发布
阅读量522 收藏
点赞数
分类专栏： AC自动机
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baidu_23081367/article/details/52331552
版权

板子：和LRJ的板子几乎一样。。略加修改了一点点一点我喜欢的变量方式而已

/*
 * AC自动机，令g[i,j]表示从i到j这一路遍历的所有字符串。 f[i]的意义就是g[?,i]和g[0,f[i]]的字符串是相等的
 * last[i] ,表示g[0,last[i]]的字符串，是确定存在的，并且以last[i]结尾的字符串*/

struct AhoCorasickAutomata {
	int ch[MAXNODE][SIGMA_SIZE];
	int f[MAXNODE];    // fail函数
	int val[MAXNODE];  // 每个字符串的结尾结点都有一个非0的val
	int last[MAXNODE]; // 输出链表的下一个结点
	int cnt[MAXNODE];
	int sz;
	queue<int>q;

	void init() {
		sz = 1;
		memset(ch[0], 0, sizeof(ch[0]));
		memset(cnt, 0, sizeof(cnt));
		ms.clear();
	}

	// 字符c的编号
	int idx(char c) {
		return c-'a';
	}

	// 插入字符串。v必须非0
	void insert(char s[], int len, int v) {
		int now = 0;
		for(int i = 0; i < len; i++) {
			int c = idx(s[i]);
			if(!ch[now][c]) {
				memset(ch[sz], 0, sizeof(ch[sz]));
				val[sz] = 0;
				ch[now][c] = sz++;
			}
			now = ch[now][c];
		}
		val[now] ++;//单词出现次数
		//ms[string(s)] = v;
	}

	// 递归打印以结点j结尾的所有字符串
	void print(int j) {
		if(j) {
			//cnt[val[j]]++;
			cnt[j]=1;
			print(last[j]);
		}
	}

	// 在T中找模板，text串的下标从0开始，长度为len
	int find(char text[], int len) {
		int j = 0; // 当前结点编号，初始为根结点
		for(int i = 0; i < len; i++) { // 文本串当前指针
			int c = idx(text[i]);
			while(j && !ch[j][c]) j = f[j]; // 顺着细边走，直到可以匹配
			j = ch[j][c];
			if(val[j]) 	print(j);
			else if(last[j]) print(last[j]); // 找到了！
		}
	}


	//计算fail指针
	void get_fail()
	{
		f[0] = 0;//fail[i]表示，当匹配到某个位置失败，下一个自动的位置
		for (int c = 0; c < SIGMA_SIZE; c++)
		{
			int will = ch[0][c];
			if (will)
			{
				f[will]=0;
				q.push(will);
				last[will] = 0;
			}
		}
		while (!q.empty())
		{
			int now = q.front();
			q.pop();
			for (int c = 0; c < SIGMA_SIZE; ++ c)
			{
				int will = ch[now][c];	//now节点，想要访问的下标
				if (!will)	continue;//如果这个下标不存在，直接continue;
				q.push(will);		
				int pre = f[now];	//失配指针,先指now的失配，至少有一段都是相等的
				while (pre && !ch[pre][c])	pre = f[pre];//往前跳失配指针，类似 KMP
				f[will] = ch[pre][c];	//f为成功指针，指向应该的方向
				last[will] = val[f[will]] ? f[will] : last[f[will]];
			}
		}
	}

	void doit()
	{

		/*
		 * 调试ac自动机数组信息用的
		for (int i = 0; i < sz; ++ i)
		{
			prln(i);
			for (int j = 0; j < 26;++j)
			{
				if (ch[i][j])	cout<< ((char)(j+'a'))<<" "<<ch[i][j]<<endl;;
			}
			//cout<<endl;
			//cout<<endl;
		}

		for (int i = 0; i < sz; ++ i)
		{
			pr(i),prln(val[i]);
		}

		for (int i = 0; i < sz; ++ i)
		{
			pr(i),prln(f[i]);
		}

		for (int i = 0; i < sz; ++ i)
		{
			pr(i),prln(last[i]);
		}
		*/

		int ans = 0;
		for (int i = 0; i != sz; ++ i)
		{
			ans += val[i] * cnt[i];
		}
		cout<<ans<<endl;
	}
}ac;



ac code:

#include<cstring>
#include <iostream>
#include<queue>
#include<cstdio>
#include<map>
#include<string>
using namespace std;

const int SIGMA_SIZE = 26;
const int MAXNODE = 500000 * 3;
#define prln(x)	cout<<#x<<" = "<<x<<endl
#define pr(x)	cout<<#x<<" = "<<x<<" "

map<string,int> ms;


/*
 * AC自动机，令g[i,j]表示从i到j这一路遍历的所有字符串。 f[i]的意义就是g[?,i]和g[0,f[i]]的字符串是相等的
 * last[i] ,表示g[0,last[i]]的字符串，是确定存在的，并且以last[i]结尾的字符串*/

struct AhoCorasickAutomata {
	int ch[MAXNODE][SIGMA_SIZE];
	int f[MAXNODE];    // fail函数
	int val[MAXNODE];  // 每个字符串的结尾结点都有一个非0的val
	int last[MAXNODE]; // 输出链表的下一个结点
	int cnt[MAXNODE];
	int sz;
	queue<int>q;

	void init() {
		sz = 1;
		memset(ch[0], 0, sizeof(ch[0]));
		memset(cnt, 0, sizeof(cnt));
		ms.clear();
	}

	// 字符c的编号
	int idx(char c) {
		return c-'a';
	}

	// 插入字符串。v必须非0
	void insert(char s[], int len, int v) {
		int now = 0;
		for(int i = 0; i < len; i++) {
			int c = idx(s[i]);
			if(!ch[now][c]) {
				memset(ch[sz], 0, sizeof(ch[sz]));
				val[sz] = 0;
				ch[now][c] = sz++;
			}
			now = ch[now][c];
		}
		val[now] ++;//单词出现次数
		//ms[string(s)] = v;
	}

	// 递归打印以结点j结尾的所有字符串
	void print(int j) {
		if(j) {
			//cnt[val[j]]++;
			cnt[j]=1;
			print(last[j]);
		}
	}

	// 在T中找模板，text串的下标从0开始，长度为len
	int find(char text[], int len) {
		int j = 0; // 当前结点编号，初始为根结点
		for(int i = 0; i < len; i++) { // 文本串当前指针
			int c = idx(text[i]);
			while(j && !ch[j][c]) j = f[j]; // 顺着细边走，直到可以匹配
			j = ch[j][c];
			if(val[j]) 	print(j);
			else if(last[j]) print(last[j]); // 找到了！
		}
	}


	//计算fail指针
	void get_fail()
	{
		f[0] = 0;//fail[i]表示，当匹配到某个位置失败，下一个自动的位置
		for (int c = 0; c < SIGMA_SIZE; c++)
		{
			int will = ch[0][c];
			if (will)
			{
				f[will]=0;
				q.push(will);
				last[will] = 0;
			}
		}
		while (!q.empty())
		{
			int now = q.front();
			q.pop();
			for (int c = 0; c < SIGMA_SIZE; ++ c)
			{
				int will = ch[now][c];	//now节点，想要访问的下标
				if (!will)	continue;//如果这个下标不存在，直接continue;
				q.push(will);		
				int pre = f[now];	//失配指针,先指now的失配，至少有一段都是相等的
				while (pre && !ch[pre][c])	pre = f[pre];//往前跳失配指针，类似 KMP
				f[will] = ch[pre][c];	//f为成功指针，指向应该的方向
				last[will] = val[f[will]] ? f[will] : last[f[will]];
			}
		}
	}

	void doit()
	{

		/*
		 * 调试ac自动机数组信息用的
		for (int i = 0; i < sz; ++ i)
		{
			prln(i);
			for (int j = 0; j < 26;++j)
			{
				if (ch[i][j])	cout<< ((char)(j+'a'))<<" "<<ch[i][j]<<endl;;
			}
			//cout<<endl;
			//cout<<endl;
		}

		for (int i = 0; i < sz; ++ i)
		{
			pr(i),prln(val[i]);
		}

		for (int i = 0; i < sz; ++ i)
		{
			pr(i),prln(f[i]);
		}

		for (int i = 0; i < sz; ++ i)
		{
			pr(i),prln(last[i]);
		}
		*/

		int ans = 0;
		for (int i = 0; i != sz; ++ i)
		{
			ans += val[i] * cnt[i];
		}
		cout<<ans<<endl;
	}
}ac;

char text[1000031];
char tmp[100];
int n;

int main() {
	int T;
	scanf("%d", &T);

	while (T--)
	{
		ac.init();
		scanf("%d", &n);
		for(int i = 1; i <= n; i++) {
			scanf("%s", tmp);
			ac.insert(tmp, strlen(tmp), i);
		}
		//ac.get_fail();
		ac.get_fail();
		scanf("%s", text);
		ac.find(text, strlen(text));
		ac.doit();
	}
	return 0;
}

节约内存版AC自动机（慢一倍）

#include <bits/stdc++.h>
#include <ext/pb_ds/priority_queue.hpp>
#include <tr1/unordered_map>
using std::tr1::unordered_map;
//using std::setiosflags;
//using std::setprecision;
using std::sort;
using std::max;
using std::min;
using std::cout;
using std::stack;
using std::cin;
using std::endl;
using std::swap;
using std::pair;
using std::vector;
using std::set;
using std::map;
using std::make_pair;
using std::multiset;
using std::unique;
using std::queue;
using std::greater;
using std::string;
using std::priority_queue;
using std::lower_bound;//返回第一个不小于
using std::upper_bound;//返回第一个大于
using std::max_element;
using std::min_element;
using __gnu_pbds::pairing_heap_tag;
#define x first
#define y second
#define mp make_pair
#define Hash unordered_map
#define clr(x) memset(x,0,sizeof(x))
#define logz(x) (31-__builtin_clz((int)x))
#define logzl(x) (63-__builtin_clzll((LL)x))
#define cf std::ios::sync_with_stdio(0);std::cin.tie(0)
typedef unsigned long long uLL;
typedef long long LL;
typedef pair<int, int> pii;
typedef pair<double, double> pdd;
typedef __gnu_pbds::priority_queue<pii, greater<pii>, pairing_heap_tag> Heap;//小根堆
typedef Heap::point_iterator Hit;
const Hit null;
const double PI = acos(-1);
const LL LINF = 0x3f3f3f3f3f3f3f3fll;//4e18
const int INF = 0x3f3f3f3f;//1e9
const double eps = 1e-8;
const int MOD = 1e9 + 7;

#define pr(x)	cout<<#x<<" = "<<x<<" "
#define prln(x)	cout<<#x<<" = "<<x<<endl
char patt[1000010];
char s[1000010];
int vis[1000010];
int n;

const int MAXNODE = 1000010;
int ans = 0;

struct AhoCorasickAutomata {
	int head[MAXNODE]; // head[i]为第i个结点的左儿子编号  
	int next[MAXNODE]; // next[i]为第i个结点的右兄弟编号  
	char ch[MAXNODE];  // ch[i]为第i个结点上的字符  
	//int tot[MAXNODE];  // tot[i]为第i个结点为根的子树包含的叶结点总数  
	int val[MAXNODE];
	int last[MAXNODE];
	int f[MAXNODE];	//fail指针
	int sz; // 结点总数  
	int cnt[MAXNODE];
	queue<int>q;

	void init() 
	{ 
		// 初始时只有一个根结点  
		sz = 1; 
		//tot[0] = 0;
		head[0] = next[0] = 0; 
		memset(val, 0, sizeof(val));
		memset(last, 0, sizeof(last));
		memset(f, 0, sizeof(f));
		memset(cnt,0,sizeof(cnt));
	} 

	// 插入字符串s，沿途更新tot  
	void insert(char s[], int len) {  
		int now = 0, will;  
		//tot[0]++;  
		for(int i = 0; i < len; i++) {  
			// 找字符s[i]  
			bool found = false;  
			for(will = head[now]; will; will = next[will])  
				if(ch[will] == s[i]) // 找到了  
				{ 
					found = true;  
					break;  
				}  
			if(!found) 
			{  
				will = sz++; // 新建结点  
				//tot[will] = 0;  
				ch[will] = s[i];  
				next[will] = head[now];  
				head[now] = will; // 插入到链表的首部  
				head[will] = 0;  
			}  
			now = will;  
			//tot[now]++;  
		}  
		val[now] ++ ;
	}  

	int is_son(int now, char t)//查找now节点，的t字符,有则返回下标，否则返回0(root)
	{
		//ch是否是now的儿子
		for (int will = head[now]; will; will = next[will])
		{
			if (ch[will]==t)	return will;
		}
		return 0;
	}
	
	void get_fail()
	{
		f[0] = 0;//fail[i]表示，当匹配到某个位置失败，下一个自动的位置
		for (int now = head[0]; now; now = next[now])
		{
			f[now]=0;
			q.push(now);
			last[now] = 0;
		}
		while (!q.empty())
		{
			int now = q.front();
			q.pop();
			for (int will = head[now]; will; will = next[will])
			{
				q.push(will);		
				int pre = f[now];	//失配指针,先指now的失配，至少有一段都是相等的
				while (pre && !is_son(pre,ch[will]))	pre = f[pre];//往前跳失配指针，类似 KMP
				f[will] = is_son(pre, ch[will]);	// f[i]的意义就是g[?,i]和g[0,f[i]]的字符串是相等的
				last[will] = val[f[will]] ? f[will] : last[f[will]];
			}
		}
	}

	// 递归打印以结点j结尾的所有字符串
	void print(int j) //输出j节点的信息，如果last[j]存在，last[j]的位置也有字符
	{
		if(j) 
		{
			//vis[pos] = max(val[j], vis[pos]);
			cnt[j]=1;
			print(last[j]);
		}
	}

	int idx(char ch)
	{
		if ('a' <= ch && ch <='z')	return ch;
		if ('A' <= ch &&  ch <='Z')	return ch -'A'+'a';
		return ch;
	}

	// 在T中找模板，text串的下标从0开始，长度为len
	void find(char text[], int len) {
		int j = 0; // 当前结点编号，初始为根结点
		for(int i = 0; i < len; i++) { // 文本串当前指针
			char c = text[i];
			while (j && !is_son(j, c))	j = f[j];
			j = is_son(j, c);
			if(val[j]) 	print(j);
			else if(last[j]) print(last[j]); // 找到了！
		}
		int ans=0;
		for (int i = 0;i<=sz; ++i)
			ans += cnt[i]*val[i];
		cout<<ans<<endl;
	}
}ac;

void init()
{
	scanf("%d ", &n);
	ac.init();
	for (int i = 1; i <=n;++i)
	{
		gets(s);
		ac.insert(s, strlen(s));
	}
	ac.get_fail();
	gets(patt);
	ac.find(patt, strlen(patt));
}

int main()
{
	int T;
	scanf("%d",&T);
	while (T--)
	{
		init();
	}
	return 0;
}





CMTM4
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多串匹配-AC自动机
wallace0611的专栏
02-25 770
<br />AC自动机即 Aho-Corasick automation，该算法在1975年产生于贝尔实验室。AC自动机是用来处理多串匹配问题的，即给你很多串，再给你一篇文章，让你在文章中找这些串是否出现过，在哪出现。AC自动机思想简单来讲就是在 Trie 上进行 KMP 匹配，所以先要知道 Trie数据结构  和 KMP算法 。 AC自动机先将所有模式串构建成单词树，如有模式串 { she, he, say, shr, her, ayd }，我们先构建成如下单词树：假设我们现在要对串 yshersay
HDU - 2896 病毒侵袭(AC自动机)
Falcon的博客
02-02 250
题目链接：点击查看 题目大意：给出 n 个模式串，再给出 m 个匹配串，问有多少个模式串在匹配串中出现，需要分别对应上其编号 题目分析：对应编号问题我们可以直接开一个数组映射，也是比较经典的模板问题了，注意输出格式就好了，还有如果MLE的话，用指针的朋友可以用C++交一下试试，用数组的朋友不要滥用memset，剩下的就是模板了 代码： #include<iostream>...
【C++STL】unordered_map
ETO的博客
07-20 4019
unordered_map 前言 如果想对unordered_map有一个全面了解的读者可以参考：unordered_map - C++ Reference 正文 下面直接说怎样实现： #include<tr1/unordered_map>//在unordered...
AC自动机的学习
qq_42211531的博客
01-22 127
花了一天把AC最基础的东西弄明白了，想弄清楚AC自动机就得学会KMP和字典树，因为这个算法是这个两个算法的基础上建立的。我们得明白字典树如何建立的和得深度理解KMP中next数组得含义。AC自动机中的fail指针和KMP中的next数组有异曲同工之处。fail指针的作用：在失配时能够跳转到合适的位置继续匹配。   AC自动机自己也是学习了基础，博客肯定时写不出来的。。。。。 参考博客： A...
字典树问题与AC自动机
u012864854的博客
04-10 746
    Trie树，又称字典树，单词查找树或者前缀树，是一种用于快速检索的多叉树结构，如英文字母的字典树是一个26叉树，数字的字典树是一个10叉树。字典树的核心就是空间换时间，空间消耗大，但是插入和查询有着很优秀的时间复杂度，利用字符串的公共前缀来避免无谓的字符串比较，降低查询时间。    Trie树的平均高度h为单词平均长度len，所以Trie树的查询复杂度为O（h）=O（len）字典树节点： ...
hdu 2222 AC自动机
退役ACMer
05-05 364
传送门 : HDU 2222注意有相同模式串出现的可能， 且每个串最多记一次答案code:#include <iostream> #include <cstdio> #include <cstring> #include <string> using namespace std; #define clr(a) memset(a, 0, sizeof a)const int N = 10010 * 5
HDU 2222 AC 自动机
neweryyy的博客
09-14 130
题意 传送门 HDU 2222 题解 多模式匹配，裸的 ACACAC 自动机。 #include <algorithm> #include <cmath> #include <cstdio> #include <cstring> #include <queue> using namespace std; #define maxn 10000 #define maxl 1000005 struct node { int cnt, a[26];
hdu2222 AC自动机
qq_52709599的博客
07-27 75
#include <stdlib.h> #include <string.h> struct Node { int cnt;//是否为该单词的最后一个结点 Node *fail;//失败指针 Node *next[26];//Trie中每个结点的各个节点 }*queue[500005];//队列，方便用BFS构造失败指针 char s[1000005];//主字符串 char keyword[55];//需要查找的单词 Node *root;//头结点 void
HDU2222 AC自动机水题 (Trie图优化)
Free Loop~~~跳动的恒星
02-27 501
#include #include #include #include #include #define For(i,j,k) for (i=j;i<=k;i++) using namespace std; struct node{ int count,flag; bool r; struct node *next[26],*fa,*fail; node(){ co
hdu 3341(ac自动机+状态压缩)
10-29
hdu 3341(ac自动机+状态压缩) 题意：容易理解... 思路：首先一开始容易想到要用到dp，开设一个dp[41][41][41][41][501]的数组来解决，但是明显内存已经超出范围了，于是就想如何减少内存呢？只要知道A、T、C、G其中...
AC自动机模板+例题（HDU2896+HDU3065+HDU2222）
SarenSage的博客
07-24 221
病毒侵袭中（HDU2896） #include<map> #include<cmath> #include<queue> #include<vector> #include<cstdio> #include<string> #include<cstdlib> #include<cstring> ...
HDU 2222(AC自动机)
qq_44641782的博客
02-25 248
Problem Description In the modern time, Search engine came into the life of everybody like Google, Baidu, etc. Wiskey also wants to bring this feature to his image retrieval system. Every image have a...
C++ 详解解读AC自动机算法 例题：HDU2222 附上完整模板代码
超逸の学习技术博客
07-20 691
AC自动机简介： 首先简要介绍一下AC自动机：Aho-Corasick automation，该算法在1975年产生于贝尔实验室，是著名的多模匹配算法之一。一个常见的例子就是给出n个单词，再给出一段包含m个字符的文章，让你找出有多少个单词在文章里出现过。要搞懂AC自动机，先得有字典树Trie和KMP模式匹配算法的基础知识。KMP算法是单模式串的字符匹配算法，AC自动机是多模式串的字符匹配算法。 A...
HDU 2243 AC自动机->DP->附矩阵乘法板子
ACMer不要报考高校代码为13627的移通学院！
08-28 1850
题目大意： 给一些字母串，问长度为L【以内】的全部字母串中，有多少个字母串，【包含】给定的字母串。答案mod 2^64 首先，对于答案mod 2^64,只要全部使用unsigned long long进行运算，就会自动实现这个功能了。 然后假设，问题只求长度为L，而不是长度小于L的，这个问题怎么做呢？ 参考前一个题解…… 题目转换为求【不包含】给定字母串来
uva 11468 ac自动机+概率DP+简单的数据生成器
ACMer不要报考高校代码为13627的移通学院！
08-27 654
ans[i][j]表示在i节点，走j步，正好停留在有单词的节点的概率。 对于有单词的节点p， ans[p][0]=1,  ans[p][other]=0 然后直接暴力概率转移即可。 写的不优美。。网上看搜了别人的程序，思想大致相同…… 但是大家的程序优美一些 这次AV自动机，得按照LRJ说的那样改一下ch数组，直接实现失配指针的链接。这样后面DP好写一些。
uva 11019 题目数据不合法！
ACMer不要报考高校代码为13627的移通学院！
08-28 592
经过试验，题目数据中，有各种不合法情况，只能使用scanf %s进行读入。否则会出现各种问题。 即使用网上别人的标程，进行修改为gets一样会挂。 还有网上一些同学的程序对拍后出现错误。。也AC了，数据太弱。 我的程序十分缓慢。。。现在正在研究原因。。(2300ms) 直接AC自动机强行跑每一行的串即可 #include #include #in
【USACO3.1.5】联系 位运算/KMP/AC自动机
ACMer不要报考高校代码为13627的移通学院！
02-24 549
吐槽：这题的输出真恶心恶心恶心恶心恶心*10000…… TLE方法： 暴力KMP，把所有的100 101 111之类的方案，全部和原串匹配一次…… 然后排序输出。 Compiling... Compile: OK Executing... Test 1: TEST OK [0.008 secs, 9424 KB] Test 2: TEST OK [0.003 sec
HDU2222+WA
最新发布
03-08
HDU2222+WA 是指杭电OJ（杭州电子科技大学在线评测系统）上的一道题目，题目编号为2222，题目名称为"WA"。这道题目是一个字符串匹配的问题，要求判断一个字符串中是否包含另一个字符串中的所有字符（不考虑顺序）。如果包含，则输出"YES"，否则输出"NO"。 解题思路可以使用哈希表来记录字符串中每个字符的出现次数，然后遍历另一个字符串，检查每个字符在哈希表中的出现次数是否大于等于1。如果所有字符都满足条件，则输出"YES"，否则输出"NO"。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值