Codeforces Gym 101064E A Word to Trump All [AC自动机+bfs]

本文介绍了一种使用AC自动机解决特定字符串问题的方法,即寻找一个最短的字符串,该字符串需包含指定的若干子串且不包含另一组指定的子串。通过构建AC自动机并进行广度优先搜索,最终找到符合条件的最短字符串。

题意:求一个字符串,必须包含给的前n个字符串,不能包含后m个字符串,求最短的答案串。

题解:建立AC自动机,对需要加入的字符串的末尾加入该标号,不能加入的串末尾记录-1,从原点开始bfs,每个节点记录Vis[305][30005]表示该节点已经搜过的需要的字符串的state,总的复杂度是O(sum*(1<<15)*10)。

AC代码:

#include<stdio.h>
#include<string.h>
#include<queue>
#define maxlen 305
#include<algorithm>
using namespace std;
int vis[305][33000];
int q[10000005][2];//位置 状态
int pre[10000005],num[10000005];
struct Trie
{
	int next[maxlen][10],fail[maxlen],end[maxlen],root,L;//next记录节点,在这里end指针代表以当前节点为字符串尾的字符串个数 
	int newnode()
	{
		for(int i=0;i<10;i++)
			next[L][i]=-1;//节点连接的边初始化为-1 
		end[L]=0;
		return L++;
	}
	void init()
	{
		L=0;
		root=newnode();
	}
	void insert(char buf[],int flag,int biaohao)//trie树的建立 
	{
		int l=strlen(buf);
		int now=root;
		for(int i=0;i<l;i++)
		{
			if(next[now][buf[i]-'a']==-1)next[now][buf[i]-'a']=newnode();
			now=next[now][buf[i]-'a'];
		}
		if(flag){
			end[now]=-1;
		}
		else end[now]|=(1<<biaohao);
	}
	void build()//建立ac自动机 
	{
		queue<int>que;
		for(int i=0;i<10;i++)
		{
			if(next[root][i]==-1)next[root][i]=root;
			else                                 //若有连边则将节点加入队列 ,并将fail指针指向root 
			{
				fail[next[root][i]]=root;
				que.push(next[root][i]);
			}
		}
		while(!que.empty())
		{
			int now=que.front();
			que.pop();
			if(end[fail[now]]>0)//状态转移 
				end[now]|=end[fail[now]];
			if(end[fail[now]]==-1)
				end[now]=-1;
			
			for(int i=0;i<10;i++)
			{
				if(next[now][i]==-1)			//若无连边,则将该边指向当前节点fail指针指向的相应字符连接的节点 
					next[now][i]=next[fail[now]][i];
				else 							//若有连边,则将儿子节点的fail指针指向当前节点fail指针指向相应字符接的节点 
				{
					fail[next[now][i]]=next[fail[now]][i];
					que.push(next[now][i]);	//加入队列继续遍历 
				}
			}
		}
	}
}ac;
int gra[305][305];
char s[305];
int main()
{
	memset(vis,0,sizeof(vis));
	vis[0][0]=1;
	ac.init();
	int n,m;
	scanf("%d%d",&n,&m);
	int zong=(1<<n)-1;
	for(int i=0;i<n;i++)
	{
		scanf("%s",s);
		ac.insert(s,0,i);
	}
	for(int i=0;i<m;i++)
	{
		scanf("%s",s);
		ac.insert(s,1,0);
	}
	ac.build();
	
	for(int i=0;i<ac.L;i++){
		for(int j=0;j<10;j++){
			gra[i][ac.next[i][j]]=j;
		}
	}
	
	int front,rear;
	front=rear=1;
	num[front]=0;
	pre[front]=-1;
	while(front<=rear){
		int x=q[front][0];
		int state=q[front][1];
		front++;
		for(int j=0;j<10;j++)
	    {
			int xx=ac.next[x][j];
			if(ac.end[xx]<0)continue;
			int state1=(state|(ac.end[xx]));
			if(!vis[xx][state1]){
				vis[xx][state1]=1;
				rear++;
				q[rear][0]=xx;
				q[rear][1]=state1;
				pre[rear]=front-1;
				num[rear]=xx;
				if(state1==zong){
					int len=0;
					int now=rear;
					while(pre[now]!=-1){
						s[len++]=gra[num[pre[now]]][num[now]]+'a';
						now=pre[now];
					}
					reverse(s,s+len);
					printf("%s\n",s);
					return 0;
				}
			}
		}
	}
	printf("-\n");
	return 0;
}


Codeforces Gym 101630 是一场编程竞赛,通常包含多个算法挑战问题。这些问题往往涉及数据结构、算法设计、数学建模等多个方面,旨在测试参赛者的编程能力和解决问题的能力。 以下是一些可能出现在 Codeforces Gym 101630 中的题目类型及解决方案概述: ### 题目类型 1. **动态规划(DP)** 动态规划是编程竞赛中常见的题型之一。问题通常要求找到某种最优解,例如最小路径和、最长递增子序列等。解决这类问题的关键在于状态定义和转移方程的设计[^1]。 2. **图论** 图论问题包括最短路径、最小生成树、网络流等。例如,Dijkstra 算法用于求解单源最短路径问题,而 Kruskal 或 Prim 算法则常用于最小生成树问题[^1]。 3. **字符串处理** 字符串问题可能涉及模式匹配、后缀数组、自动机等高级技巧。KMP 算法和 Trie 树是解决此类问题的常用工具[^1]。 4. **数论与组合数学** 这类问题通常需要对质数、模运算、排列组合等有深入的理解。例如,快速幂算法可以用来高效计算大数的模幂运算[^1]。 5. **几何** 几何问题可能涉及点、线、多边形的计算,如判断点是否在多边形内部、计算两个圆的交点等。向量运算和坐标变换是解决几何问题的基础[^1]。 ### 解决方案示例 #### 示例问题:动态规划 - 最长递增子序列 ```python def longest_increasing_subsequence(nums): if not nums: return 0 dp = [1] * len(nums) for i in range(len(nums)): for j in range(i): if nums[i] > nums[j]: dp[i] = max(dp[i], dp[j] + 1) return max(dp) # 示例输入 nums = [10, 9, 2, 5, 3, 7, 101, 18] print(longest_increasing_subsequence(nums)) # 输出: 4 ``` #### 示例问题:图论 - Dijkstra 算法 ```python import heapq def dijkstra(graph, start): distances = {node: float('infinity') for node in graph} distances[start] = 0 priority_queue = [(0, start)] while priority_queue: current_distance, current_node = heapq.heappop(priority_queue) if current_distance > distances[current_node]: continue for neighbor, weight in graph[current_node].items(): distance = current_distance + weight if distance < distances[neighbor]: distances[neighbor] = distance heapq.heappush(priority_queue, (distance, neighbor)) return distances # 示例输入 graph = { 'A': {'B': 1, 'C': 4}, 'B': {'A': 1, 'C': 2, 'D': 5}, 'C': {'A': 4, 'B': 2, 'D': 1}, 'D': {'B': 5, 'C': 1} } start = 'A' print(dijkstra(graph, start)) # 输出: {'A': 0, 'B': 1, 'C': 3, 'D': 4} ``` #### 示例问题:字符串处理 - KMP 算法 ```python def kmp_failure_function(pattern): m = len(pattern) lps = [0] * m length = 0 # length of the previous longest prefix suffix i = 1 while i < m: if pattern[i] == pattern[length]: length += 1 lps[i] = length i += 1 else: if length != 0: length = lps[length - 1] else: lps[i] = 0 i += 1 return lps def kmp_search(text, pattern): n = len(text) m = len(pattern) lps = kmp_failure_function(pattern) i = 0 # index for text j = 0 # index for pattern while i < n: if pattern[j] == text[i]: i += 1 j += 1 if j == m: print("Pattern found at index", i - j) j = lps[j - 1] elif i < n and pattern[j] != text[i]: if j != 0: j = lps[j - 1] else: i += 1 # 示例输入 text = "ABABDABACDABABCABAB" pattern = "ABABCABAB" kmp_search(text, pattern) # 输出: Pattern found at index 10 ``` ###
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值