子序列自动机 学习笔记

因为在某场比赛上没学过子序列自动机而被搞了心态，听说是最简单的一种自动机，就赶紧来点亮技能树（

简介

子序列自动机，好像也称序列自动机，是一种可以快速判断字符串 $t$ 是否是字符串 $s$ 子串的算法。

这是一个很朴素的算法，本质上就是利用空间来换取时间。

实现

1. 原理

假设现有一字符串 $s$ ，我们定义一数组 $nxt_{i,j}$ ，其意义为对于串 $s$ ，从第 $i$ 个位置后的字符串中元素 $j$ 首次出现的位置。此时对于另一串 $t$ ，若 $t$ 为 $s$ 的子串，则 $t$ 的每个位置的元素，可以利用 $nxt$ 数组在 $s$ 上的剩余字串得到匹配。

2. 构造 $nxt$ 数组

对于构造 $nxt$ 数组，我们可以从后往前枚举原串的每一个位置，先进行 $nxt_{i,j}=nxt_{i+1,j}$ 的初始化，在根据原串当前位置元素对 $nxt$ 数组进行修改。

代码如下：

for(int i=n-1;i>=0;i--)
{
    for(int j=1;j<=m;j++) nxt[i][j]=nxt[i+1][j];
    nxt[i][s[i+1]]=i+1;
}

时间复杂度为 $O(|S|m)$ ，其中 $m$ 为元素个数。

3. 查找

构造出 $nxt$ 数组后我们就可以进行查找子串操作。

我们定义指针 $now=-1$ ,对于每次匹配，指针 $now$ 都跳转到 $nxt_{now+1,t[j]}$ 的位置。如果当前 $now$ 的指向值为空（或者为 $n$ ，取决于 $nxt$ 的初始化），则说明母串中无法找到子串 $t$ 。

代码如下：

int p=-1;
for(int i=0;i<n;i++)
{
    p=nxt[p+1][t[i]];
    if(!p) return false;
}
return true;

时间复杂度为 $O(\Sigma|T|)$ 。

4. 其他优化

我们来看看这道模板 P5826 【模板】子序列自动机

瞄一眼数据范围，$n ≤ 10^5$ ，先不论时间够不够，空间是妥妥的会炸。

根据子序列自动机的思路，为了找第 $i$ 位置后 $j$ 元素的位置，我们可以考虑将原串中每一个 $j$ 元素的位置记录下来，二分出第一个大于 $i$ 的位置。

所以我们可以开 $m$ 个 $vector$ 数组，存下下标，进行二分。

代码如下：

vector<int> nxt[MAXN];
int main()
{
	type=Read();n=Read();q=Read();m=Read();
	for(int i=1;i<=n;i++)
	{
		int x=Read();
		nxt[x].push_back(i);
	}
	for(int i=1;i<=q;i++)
	{
		int len=Read(),now=0,flag=1;
		for(int j=1;j<=len;j++)
		{
			int x=Read();
			if(!flag) continue;
			vector<int>::iterator it=lower_bound(nxt[x].begin(),nxt[x].end(),now+1);
			if(it==nxt[x].end()) flag=0;
			else now=*it;
		}
		if(flag) printf("Yes\n");
		else printf("No\n");
	}
	return 0;
}

时间复杂度为 $O(n+(\Sigma|T|)logn)$ ，空间复杂度为 $O(n+m)$

好像可以用主席树来写，但是我不会qwq

哪天会了来补

例题

• 判断是否原串子序列

子序列自动机的基础应用。

• 求一个字符串的子序列个数

处理出 $nxt$ 数组之后可以对该串进行 $dp$

设 $f[v][j]$ 表示从 $1$ 到 $v$ 中长度为 $j$ 的子序列个数

则易得 $f[v][j]=\sum\limits_{nxt[u][i]=v}f[u][j-1]$

queue<int> q;
int f[MAXN][MAXN],d[MAXN];
void Dp()
{
    f[0][0]=1;
    q.push(0);
    while(!q.empty())
    {
        int u=q.front();q.pop();
        for(int i=1;i<=m;i++)
        {
            if(!nxt[u][i]) continue;
            for(int j=0;j<=u;j++) f[nxt[u][i]][j+1]+=f[u][j];
            d[nxt[u][i]]--;
            if(!d[nxt[u][i]]) q.push(nxt[u][i]);
        }
    }
}

其实可以看出这个本质上就是在 $DAG$ 上跑拓扑 $dp$ ，所以 $nxt$ 数组本质上就是一个 $DAG$

• 求两串的公共子序列个数

将两串的 $nxt$ 数组先处理出来，设 $f[i][j]$ 表示 两串分别以位置 $i$ 和位置 $j$ 为起点的公共子序列个数，然后 $Dfs$ 一下就行了。

int f[MAXN][MAXN];
int Dfs(int i,int j)
{
    if(f[i][j]) return f[i][j];
    for(int now=1;now<=n;now++)
        if(nxta[i][now]&&nxtb[j][now])
            f[i][j]+=Dfs(nxta[i][now],nxtb[j][now]);
    return ++f[i][j];
}

可以根据需要用 $map$ 来储存个数。

• 求字符串的回文子序列个数

回文其实可以看作将原串分成两部分，由两端查找公共子序列。

所以可以正向和反向处理出 $nxt$ 数组，注意反向处理的时候从右到左位置递增，然后进行 $Dfs$ ，易得当匹配的两位置 $x+y≤n+1$ 时记录答案。由于这里我们只能统计长度为偶数的子序列个数，对于奇数长度的我们需要另加一。

int f[MAXN][MAXN];
int Dfs(int x,int y)
{
    if(f[x][y]) return f[x][y];
    for(int i=0;i<26;i++)
    {
        if(nxtl[x][i]+nxtr[y][i]>n+1) continue;
        if(nxtl[x][i]+nxtr[y][i]<n+1) f[x][y]++;
        f[x][y]+=Dfs(nxtl[x][i],nxtr[y][i]);
    }
    return ++f[x][y];
}

参考资料

题解 P5826 【【模板】子序列自动机】

题解 P1819 【公共子序列_NOI导刊2011提高（03）】

更新中（