序列自动机(板子总结+例题)

博客围绕一个模式串和多个询问串展开,探讨询问串是否为模式串子序列的问题。通过构建序列自动机解决,介绍了自动机的构建思路、预处理和匹配复杂度,还分享了建自动机的心得,如优先出现字母先构建等。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

题目

一个模式串s(|s|<=1e5),

n(n<=1e5)个询问,每次询问一个串t(|t|<=1e3)

每次询问t是不是s的子序列

思路来源

https://blog.youkuaiyun.com/gemorz/article/details/53184721

题解

建一下序列自动机,然后每次在自动机上跑一下,

类似trie树,看看是否存在即可

预处理自动机O(26*|s|),匹配O(n*t)

心得

算是学习了一下序列自动机

建子序列自动机的时候,优先出现的字母先构建

比如aaabab的ab串,就是由第一个a和第四个b建的

这样保证了不会错过后续来的字符串

此外,每次加入一个新字符时,考虑能给哪些子序列带来贡献

那么就是在以往所有的子序列后增加一个新字符即可,

只需枚举过往所有子序列的最后一个字符是什么,

而由于序列自动机的优先性,

任意一个子序列的最后一个字符x,肯定是最后一个被加入的字符x,

所以从‘a’到‘z'枚举,补到最后一个字符位置后面即可,

注意到这里许多子序列的儿子节点都是共用的一个节点,

所以这也使得若干子序列都是共用的,

补在这个节点后面就相当于补在所有以这个子节点为结尾节点的子序列后面

复杂度据说是O(n*a),但我觉得好像是O(所有本质不同子序列的长度之和)

代码1

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
const int maxn=1e5+10;
int n,len,rt;
char s[maxn],t[maxn];
int par[maxn];
int head[26],last[26];
int ch[maxn][26];
void add(int x)
{
    par[++rt]=last[x];
    if(!last[x])head[x]=rt;
    for(int i=0;i<26;i++)
      for(int j=last[i];j&&!ch[j][x];j=par[j])
         ch[j][x]=rt;
//共用多个节点 在每个子序列的结尾后续一个 枚举上一个串的结尾的节点是哪个
//复杂度应该为 所有本质不同的子序列长度之和 毕竟是在每个后面续字符构成新序列和新的ch关系 
    last[x]=rt;
}
bool find(char s[])
{
	int rt,len=strlen(s);
	for(int i=0;i<len;++i)
	{
		int x=s[i]-'a';
		if(!i)rt=head[x];
		else rt=ch[rt][x];
		if(!rt)return 0;
	}
	return 1;
}
//模式串s n个串t 判断t是不是s的子序列 
int main()
{
	scanf("%s",s);
	len=strlen(s);
	for(int i=0;i<len;++i)
	{
		int x=s[i]-'a';
		add(x);
	}
	scanf("%d",&n);
	for(int i=0;i<n;++i)
	{
		scanf("%s",t);
		puts(find(t)?"YES":"NO");
	}
	return 0;
}

代码2

不妨设字符串只由小写字母构成,

Next[i][j]表示下标从i起第一次出现字母j的位置

预处理的时候倒着dp,Next[i][s[i]-'a']=i,否则Next[i][j]=Next[i+1][j]

初始时,赋状态Next[i][j]=n+1或INF

子序列匹配时,每次贪心地找到第一个字符进行匹配

预处理复杂度O(n*a),匹配复杂度O(|s|)

由于代码比较简单就不写了

### 子序列自动机的实现原理 子序列自动机(Subsequence Automaton)是一种用于高效判断一个字符串是否是另一个字符串子序列的数据结构。其核心思想是通过预处理母串,构建一个可以快速查找每个字符出现位置的索引结构,从而在匹配过程中避免重复扫描母串。 在子序列自动机中,通常使用一个二维数组或字典来记录每个字符在母串中的所有出现位置。例如,对于母串 `s`,我们可以从前往后扫描并记录每种字符(如 26 个英文字母)出现的所有下标,并将这些下标存储在一个 `vector` 或类似结构中。这样做的好处是,在后续的子序列检查中,可以通过二分查找快速定位到某个字符在母串中下一个出现的位置 [^5]。 具体来说,假设我们有一个母串 `s = "abcab"`,那么我们会为每个字符建立一个列表: - `'a'` 出现在索引 0 和 3 - `'b'` 出现在索引 1 和 4 - `'c'` 出现在索引 2 当我们要检查一个子串 `t = "acb"` 是否是母串的子序列时,我们可以维护一个指针 `pos`,初始指向 -1。然后依次处理子串中的每个字符: 1. 对于字符 `'a'`,我们在 `'a'` 的列表中找到第一个大于 `pos` 的位置(即 0),更新 `pos` 为 0。 2. 对于字符 `'c'`,我们在 `'c'` 的列表中找到第一个大于 `pos` 的位置(即 2),更新 `pos` 为 2。 3. 对于字符 `'b'`,我们在 `'b'` 的列表中找到第一个大于 `pos` 的位置(即 4),更新 `pos` 为 4。 如果在整个过程中都能找到符合条件的位置,则说明该子串是母串的子序列;否则不是。 这种方法的时间复杂度主要取决于预处理阶段和每次查询阶段。预处理阶段的时间复杂度为 O(|s|),其中 |s| 是母串的长度。每次查询的时间复杂度为 O(|t| * log n),其中 |t| 是子串的长度,n 是母串中特定字符的出现次数 [^5]。 下面是上述逻辑的一个 Python 实现示例: ```python from collections import defaultdict import bisect def build_subsequence_automaton(s): # 构建自动机:对每个字符记录其所有出现的位置 positions = defaultdict(list) for idx, char in enumerate(s): positions[char].append(idx) return positions def is_subsequence(t, automaton, s_len): # 检查 t 是否是基于自动机所构建的母串的子序列 pos = -1 # 当前匹配到母串的位置 for char in t: if char not in automaton: return False # 在当前字符的所有出现位置中找到第一个比 pos 大的位置 idx_list = automaton[char] i = bisect.bisect_right(idx_list, pos) if i == len(idx_list): return False pos = idx_list[i] return True # 示例用法 if __name__ == "__main__": s = "abcab" # 母串 automaton = build_subsequence_automaton(s) s_len = len(s) test_cases = ["acb", "ab", "aaa"] for t in test_cases: result = is_subsequence(t, automaton, s_len) print(f"'{t}' is {'a' if result else 'not a'} subsequence of '{s}'") ``` 在这个例子中,函数 `build_subsequence_automaton` 负责构建自动机,而 `is_subsequence` 则利用这个自动机来判断给定的字符串 `t` 是否是母串 `s` 的子序列。通过这种方式,可以在较短时间内完成多次子序列检查,非常适合大规模数据处理场景 [^5]。 ### 相关问题 1. 如何优化子序列自动机以应对非常大的字符集? 2. 在子序列自动机中如何处理动态更新的母串? 3. 子序列自动机与传统的暴力方法相比有哪些性能优势? 4. 如何扩展子序列自动机以支持多个母串的同时检查?
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小衣同学

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值