「Note」字符串方向 - 自动机相关

1. AC 自动机 ACAM

1.1. 简介

AC 自动机用于解决多模式串匹配问题，例如求多个模式串在文本串中的出现次数。显著地，它的应用实际上非常广泛。

借助 KMP 的思想，我们对 Trie 树上的每个节点构造其失配指针 \(fail_i\)，指向对于当前字符串的最长后缀（其他（前缀）作为当前串后缀的最长的一个），显著地，每个节点的失配指针都指向一个更短的状态。当这样的后缀不存在时，失配指针会指向表示空串的根节点。

考虑如何构建 \(fail_i\)：

根据每个节点的失配指针都指向一个更短的状态这个性质，考虑用 BFS 解决 \(fail_i\) 的构建，对于当前节点 \(now\) 来说，假设深度较小的节点都已经被处理完了。

现在假设当前节点 \(i\) 由 \(fa_i\) 经过字符 \(ch\) 转移过来，使 \(fail_i\leftarrow trans(fail_{fa_i},ch)\)，若不存在 \(fail_{fa_i}\) 通过 \(ch\) 转移到的某一节点，则尝试使 \(fail_i\leftarrow trans(fail_{fail_{fa_i}},ch)\)。直到 \(fail\) 指向根节点，说明根本不存在合法前缀，我们使 \(fail_i\leftarrow rt\)。

特殊地，若不存在 \(trans(fa,ch)\) 这个转移方式，则直接令 \(trans(fa,ch)\leftarrow trans(fail_{fa_i},ch)\)。

1.2. 常见技巧

1.2.1 fail 树的性质

构建的 \(fail\) 指针会形成一棵树，称为 fail 树。这不是废话吗。

1. fail 树为一颗有根树，可以进行树剖等树上操作。
2. 对于节点 \(p\) 与其对应字符串 \(t_p\)，对于任意一个子树内节点 \(q\)，都有 \(t_p\) 是 \(t_q\) 的后缀。逆命题亦成立。
3. 设 \(cnt_p\) 表示作为 \(t_p\) 后缀的字符串数量。若无重复串，则 \(cnt_p\) 为树上节点 \(p\) 到根节点上字符串节点数量。

1.2.2 应用

ACAM 可以与 DP 结合，在自动机中进行 DP。

1.3. 例题

\(\color{blueviolet}{P5357}\)

时间瓶颈在于每次跳 \(tail\) 的重复访问，考虑经过每个点时记录权值，最后一起统计，可以采用 DFS 或者拓扑排序。

$\text{Code}$：

#include<bits/stdc++.h>
#define LL long long
#define UN unsigned
using namespace std;
//--------------------//
//IO
inline int rd()
{
	int ret=0,f=1;char ch=getchar();
	while(ch<'0'||ch>'9'){if(ch=='-')f=-f;ch=getchar();}
	while(ch>='0'&&ch<='9')ret=ret*10+ch-'0',ch=getchar();
	return ret*f;
}
//--------------------//
const int N=2e6+5,Ch=30;

int n;
char str[N];
int id[N],ans[N];
struct Edge
{
	int to,nex;
}edge[N];
int etot,head[N];
void add(int from,int to)
{
	edge[++etot]={to,head[from]};
	head[from]=etot;
	return;
}
struct ACAM
{
	struct Trie_Node
	{
		int nex[Ch];
		int fail,flag,cnt;
	}t[N];
	int tot,fcnt;
	void insert(char *s,int temp)
	{
		int now=0,len=strlen(s+1);
		for(int i=1;i<=len;i++)
		{
			if(!t[now].nex[s[i]-'a'+1])
				t[now].nex[s[i]-'a'+1]=++tot;
			now=t[now].nex[s[i]-'a'+1];
		}
		if(!t[now].flag)
			t[now].flag=++fcnt;
		id[temp]=t[now].flag;
		return;
	}

	void get_fail()
	{
		queue<int>q;
		for(int i=1;i<=26;i++)
		{
			if(t[0].nex[i])
				q.push(t[0].nex[i]);
		}
		while(!q.empty())
		{
			int now=q.front();
			q.pop();
			for(int to,i=1;i<=26;i++)
			{
				to=t[now].nex[i];
				if(!to)
				{
					t[now].nex[i]=t[t[now].fail].nex[i];
					continue;
				}
				t[to].fail=t[t[now].fail].nex[i];
                q.push(to);
			}
		}
		return;
	}
	void get_ans(char *s)
	{
		int len=strlen(s+1),now=0;
		for(int i=1;i<=len;i++)
		{
			now=t[now].nex[s[i]-'a'+1];
			t[now].cnt++;
		}
		return;
	}
	void build()
	{
		for(int i=1;i<=tot;i++)
			add(t[i].fail,i);
		return;
	}
	void DFS(int now)
	{
		//printf("%d %d\n",now,t[now].cnt);
		for(int to,i=head[now];i;i=edge[i].nex)
		{
			to=edge[i].to;
			DFS(to);
			t[now].cnt+=t[to].cnt;
		}
		if(t[now].flag)
			ans[t[now].flag]=t[now].cnt;
		return;
	}
}A;
//--------------------//
int main()
{
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
		scanf("%s",str+1),A.insert(str,i);
	A.get_fail();
	scanf("%s",str+1);
	A.get_ans(str);
	A.build();
	A.DFS(0);
	for(int i=1;i<=n;i++)
		printf("%d\n",ans[id[i]]);
    return 0;
}

2. 后缀自动机 SAM

2.1. 简介

2.1.1. 基本定义与结论

SAM 一般用于在线性时间内解决如下问题：

• 在一个字符串中求另一字符串出现的位置。
• 一个字符串的本质不同的子串个数。

SAM 的定义：一个长为 \(n\) 的字符串 \(s\) 的SAM 是一个接受 \(s\) 的所有后缀的最小的有限状态自动机。

较为人话的说法：

• SAM 是一张有向无环图。每个节点为一个状态，边则为状态间的转移。
• 存在一个源点 \(t_0\)，称作初始状态，其他状态均可从 \(t_0\) 出发到达。
• 每个转移（边）对应一个字符（一条路径表示一个字符串），从一个状态（节点）出发的转移均不同。
• 从初始状态 \(t_0\) 出发，最终转移到一个终止状态，则此径代表的字符串一定是原字符串 \(s\) 的一个后缀，\(s\) 的每个后缀都可以用一条这种路径表示。
• 满足上述条件的自动机中，SAM 的节点数量最少。

SAM 的较为重要的一条性质:

• 从初始状态出发到任意状态的路径与串 \(s\) 的所有子串（本质不同）一一对应。

接下来给出一些定义和符号表示：

• \(c_{p,q}\)：转移 \(p\to q\) 代表的字符。
• \(\mathrm{st}(p,c)\)：状态 \(p\) 经过字符 \(c\) 转移所到达的状态。
• \(\mathrm{endpos}(t)\)：字符串 \(t\) 在原字符串中所有结束位置的集合。
• 等价类：对于 \(\mathrm{endpos}\) 集合相同的子串，我们将它们划分为一个等价类，作为一个状态。
• \(\mathrm{ep}(p)\)：状态 \(p\) 所对应的 \(\mathrm{endpos}\) 集合。
• \(\mathrm{substr}(p)\)：状态 \(p\) 所表示的所有子串的集合。
• \(\mathrm{longest}(p)\)：状态 \(p\) 所表示的所有子串中，长度最长的那一个子串。
• \(\mathrm{shortest}(p)\)：状态 \(p\) 所表示的所有子串中，长度最短的那一个子串。
• \(\mathrm{len}(p)\)：状态 \(p\) 所表示的所有子串中，长度最长的那一个子串的长度。
• \(\mathrm{minlen}(p)\)：状态 \(p\) 所表示的所有子串中，长度最短的那一个子串的长度。

方便理解，我们再次整理上述定义。SAM 的每个状态对应一个等价类，即 \(\mathrm{endpos}\) 集合相同的子串所组成的状态。具体地，我们给出例子。假设现有串 \(s=\texttt{"abcab"}\)，则 \(\mathrm{endpos}(\texttt{"ab"})=\mathrm{endpos}(\texttt{"b"})={2,5}\)，而串 \(\texttt{"ab"},\texttt{"b"}\) 便属于统一等价类。

\(\mathrm{longest}(p),\mathrm{shortest}(p),\mathrm{len}(p),\mathrm{minlen}(p)\) 则描述了状态 \(p\) 对应的字符串集合 \(\mathrm{substr}(p)\) 中最长、最短的字符串以及它们的长度。

下面介绍两个结论：

• 对于两个非空字符串 \(x,y\)（\(|x|\leq |y|\)），要么有 \(\mathrm{endpos}(x)\subseteq \mathrm{endpos}(y)\)，要么有 \(\mathrm{endpos}(x)\cup\mathrm{endpos}(y)=\varnothing\)
• 对于一个状态 \(p\)，其包含的字符串长度连续，且较短者是较长者的后缀。

两个结论的证明过程并不复杂，简单思考也可以感性理解，在这里不给出具体证明，具体可参考 Alex_Wei 的博客或者 OI-Wiki，链接见参考资料部分。

总结以上两个性质有：

• 对于一个子串 \(t\) 的所有后缀，其 \(endpos\) 集合的大小随着后缀长度减小而单调不降，并且较大的集合包含较小的集合。简单定性分析，当后缀越短时，约束条件越宽松，出现位置更可能多。

根据上面的性质，我们给出 SAM 中最核心的定义：

• 后缀链接 \(\mathrm{link}(p)\)：对于所有 \(\mathrm{ep}(p)\subseteq\mathrm{ep}(q)\)，\(\mathrm{link}(p)\) 指向 \(\mathrm{len}(q)\) 最大的那个 \(q\)。

稍微直观一点理解我们仍然用一个例子，假设现有串 \(s=\texttt{"babcab"}\)

我们假设状态 \(p\) 对应着我们的字符串集合 \(\{\texttt{"cab"}\}\)，对应有 \(\mathrm{ep}(p)=\{6\}\)。

状态 \(a\) 对应字符串集合 \(\{\texttt{"ab"}\}\)，对应有 \(\mathrm{ep}(a)=\{3,6\}\)。

状态 \(b\) 对应字符串集合 \(\{\texttt{"b"}\}\)，对应有 \(\mathrm{ep}(b)=\{1,3,6\}\)。

根据刚才的定义，现有 \(\mathrm{ep}(p)\subseteq\mathrm{ep}(a),\mathrm{ep}(p)\subseteq\mathrm{ep}(b)\)，且只有 \(a,b\) 两状态的 \(\mathrm{ep}\) 包含状态 \(p\) 的 \(\mathrm{ep}\)，又有 \(\mathrm{len}(a)>\mathrm{len}(b)\)，所以 \(\mathrm{link}(p)\) 应指向状态 \(a\)。

再次重复一下 \(\mathrm{link}(p)\) 的意义，它指向了状态 \(p\) 的所有后缀状态中（最长）长度最大的那个，易知 \(\mathrm{len}(\mathrm{link}(p))+1=\mathrm{minlen}(p)\)。

对于后缀链接有这样一条性质：

• 所有后缀链接形成一颗以 \(t_0\) 为根的树。（\(t_0\) 是我们最开始定义的初始状态，它包含了空串。）

显著的，对于任意状态（除了 \(t_0\)），沿着后缀链接移动总会达到一个 \(\mathrm{len}\) 更短的状态，直到 \(t_0\)。

后缀链接构成的树本质上是 \(\mathrm{endpos}\) 集合构成的一棵树，我们一般称为 Parent 树。

2.1.2. 关键结论

这部分主要摘自 Alex_wei 的博客，理解构建 SAM 的过程需要理解此部分的结论。如果你能较为直观地理解 Parent 树，那么这部分的结论都很显然，大部分证明请参考 Alex_wei 的博客。

第一组结论：

• 从任意状态 \(p\) 出发通过后缀链接跳转到 \(t_0\) 的路径，所有路径上的状态 \(q\) 的 \([\mathrm{minlen}(q),\mathrm{len}(q)]\) 无交集，并且范围随着在 Parent 上的深度减小而减小，并且他们的并集形成一个连续区间 \([0,\mathrm{len}(p)]\)。
• 从任意状态 \(p\) 出发通过后缀链接跳转到 \(t_0\) 的路径，所有路径上的状态 \(q\) 的 \(\mathrm{substr}(q)\) 的并集为 \(\mathrm{longest}(p)\) 的所有后缀。

第二组结论：

• 有任意状态 \(p\) 使得有从 \(p\) 到 \(q\) 的转移，对于 \(\forall t_p\in \mathrm{substr}(p)\)，有 \(t_p+c_{p,q}\in\mathrm{substr}(q)\)。
• 对于 \(\forall t_q\in\mathrm{substr}(q)\)，存在且只存在一个状态 \(p\) 使得有从 \(p\) 到 \(q\) 的转移，并且 \(\exist t_p\in \mathrm{substr}(p)\) 使得 \(t_p+c_{p,q}=t_q\)。

第三组结论：

• 不存在从状态 \(p\) 到状态 \(q\) 的转移使得 \(\mathrm{len}(p)+1>\mathrm{len}(q)\)。
• 存在唯一状态 \(p\)，有 \(p\) 到 \(q\) 的转移使得 \(\mathrm{len}(p)+1=\mathrm{len}(q)\)。
• 存在唯一状态 \(p\)，有 \(p\) 到 \(q\) 的转移使得 \(\mathrm{minlen}(p)+1=\mathrm{minlen}(q)\)。

在给出第四组结论之前，我们先给出两个定义：

• \(\mathrm{maxtrans}(q)\)：有 \(p\) 到 \(q\) 的转移使得 \(\mathrm{len}(p)+1=\mathrm{len}(q)\) 的唯一 \(p\)。
• \(\mathrm{mintrans}(q)\)：有 \(p\) 到 \(q\) 的转移使得 \(\mathrm{minlen}(p)+1=\mathrm{minlen}(q)\) 的唯一 \(p\)。

第四组结论：

• 对于转移 \(p\to q\)，一定有 \(p\) 在 Parent 树上为 \(\mathrm{maxtrans}(q)\) 或其祖先。
• 对于转移 \(p\to q\)，一定有 \(p\) 在 Parent 树上为 \(\mathrm{mintrans}(q)\) 或其子树内节点。
• 对于转移 \(p\to q\)，所有这样的 \(p\) 在 Parent 树上构成了一条深度递减链，即 \(\mathrm{mintrans}(q)\to\mathrm{maxtrans}(q)\)。

并不难理解，考虑到 Parent 树的定义以及性质，一条从上到下的链中字符串长度连续并且都为链底长串的子串。

2.1.3 SAM 的构建

至此为止，我们可以用以上的所有性质来构建 SAM 了。

我们考虑在前缀串 \(s[1,i-1]\) 的 SAM 基础上插入当前字符更新整个 SAM。

设上一状态（目前已插入的前缀所在状态）为 \(las\)，当前状态为 \(cur\)，状态总数为 \(tot\)。初始时 \(las,cnt\) 均为 \(1\)，即我们设初始状态 \(t_0=1\)。

我们使先新建编号为 \(cur\) 赋值，\(cur\) 表示的是以当前插入字符结尾前缀的状态，然后令 \(p\leftarrow las\)，\(p\) 表示我们现在更新到的节点。

考虑转移边的处理，我们将 \(p\) 沿着 Parent 树向上跳，可以保证的是每到一个节点都是 \(s[1,i-1]\) 的后缀，所以我们要更新其向 \(s_i\) 的转移，若其没有此转移，我们就为其新建出边，并继续沿着 Parent 向上跳转。直到我们到一个节点存在此转移，说明再往上的节点都有此转移，就不必再更新了。

接下来考虑 Parent 树边的构建，我们分三种情况讨论。

---

情况一：

不存在一个 \(p\) 有以 \(s_i\) 的转移。

这种情况存在且只存在于 \(s_i\) 这个字符从未被加入过，我们令 \(\mathrm{link}(cur)\leftarrow t_0\) 即可。

---

情况二：

存在 \(p\) 有以 \(s_i\) 的转移，令 \(q=\mathrm{st}(p,s_i)\)，且 \(\mathrm{len}(p)+1=\mathrm{len}(q)\)。

我们设 \(las\to t_0\) Parent 树上的路径 \(p\) 的前一个状态有 \(p'\)，并且 \(p'\) 已经新建了 \(s_i\) 的转移到 \(cur\)，根据 Parent 性质有 \(\mathrm{minlen}(cur)=\mathrm{len}(p')+1=(\mathrm{len}(p)+1)+1=\mathrm{len}(q)+1\)，根据定义令 \(\mathrm{link}(cur)\leftarrow q\)。

---

情况三：

存在 \(p\) 有以 \(s_i\) 的转移，令 \(q=\mathrm{st}(p,s_i)\)，且 \(\mathrm{len}(p)+1\not=\mathrm{len}(q)\)。

当 \(\mathrm{len}(p)+1\not=\mathrm{len}(q)\)，只能存在 \(\mathrm{len}(p)+1<\mathrm{len}(q)\)。状态 \(q\) 中有一部分是无法转移到我们当前状态 \(cur\) 的，可以理解为 \(\mathrm{substr}(q)\) 不全为 \(\mathrm{substr}(cur)\) 的后缀，因为在 \(q\) 中存在以除 \(p\) 之外的状态转移过来的部分。我们考虑将 \(q\) 分为小于等于 \(\mathrm{len}(p)+1\) 和大于 \(\mathrm{len}(p)+1\) 的两部分，并新建状态 \(cl\) 存储小于等于 \(\mathrm{len}(p)+1\) 的部分。对于继承我们需要进行以下操作：

• \(cl\) 保存所有 \(q\) 向外的转移。
• \(\mathrm{len}(cl)\) 应等于 \(\mathrm{len}(p)+1\)。
• \(\mathrm{link}(cl)\) 应等于原来的 \(\mathrm{link}(q)\)。
• 对于 Parent 树上 \(p\to t\) 路径上的状态，我们也应该将原指向 \(q\) 的转移指向 \(cl\)。
• \(\mathrm{link}(q),\mathrm{link}(cur)\) 应等于 \(cl\)。

---

在构建完 Parent 树边后，我们使 \(las\leftarrow cur\)，退出构建即可。

2.1.4. SAM 的时空间限制

对于 SAM 构造、使用时间复杂度为线性的证明略复杂，仍是可参考 Alex_Wei 的博客或者 OI-Wiki。

因为每次加入字符最多新建两个节点，所以空间应当开双倍，特殊地，当字符集很大时，可以用 map 维护转移。

2.2. 常用技巧

2.2.1. 求本质不同子串个数

考虑每个子串存在且只存在于一个状态，考虑计数所有状态中的子串总和，对于每个状态 \(i\) 有答案 \(\sum\mathrm{len}(i)-\mathrm{len}(\mathrm{link}(i))\)。

另一种考虑方式，SAM 上一条路径对应一个子串，对于每个状态求一下以此状态结尾的路径数量，最后求和，可以考虑用拓扑排序。（相当于转化为所有前缀的后缀个数。）

2.2.2. 解决匹配串问题

较为简单的，直接在 SAM 上各种跑，失配就跳 Parent，与 KMP 的思想相似。

2.2.3. 求 \(\mathrm{endpos}\) 集合大小

每加入一个新状态 \(cur\)，为其计数器打上 \(1\)，SAM 构建好后求一下 Parent 子树内计数器和即可。

2.3. 例题

\(\color{blueviolet}{P3804}\)

SAM 板子。

$\text{Code}$：

#include<bits/stdc++.h>
#define LL long long
#define UN unsigned
using namespace std;
//--------------------//
//IO
inline int rd()
{
	int ret=0,f=1;char ch=getchar();
	while(ch<'0'||ch>'9'){if(ch=='-')f=-f;ch=getchar();}
	while(ch>='0'&&ch<='9')ret=ret*10+ch-'0',ch=getchar();
	return ret*f;
}
//--------------------//
const int N=1e6+5,N2=2e6+5;

struct Edge
{
    int to,nex;
}edge[N2];
int etot,head[N2];
void add(int from,int to)
{
    edge[++etot]={to,head[from]};
    head[from]=etot;
    return;
}

char s[N];
struct SAM
{
    struct SAM_Node
    {
        int nex[30];
        int len,fa;
        int cnt;
    }a[N2];
    int las=1,tot=1;
    void insert(char ch)
    {
        int it=ch-'a'+1,p=las;
        int cur=++tot;
        a[cur].len=a[las].len+1,las=cur,a[cur].cnt=1;
        while(!a[p].nex[it]&&p)
            a[p].nex[it]=cur,p=a[p].fa;
        if(!p)
        {
            a[cur].fa=1;
            return;
        }
        int q=a[p].nex[it];
        if(a[p].len+1==a[q].len)
        {
            a[cur].fa=q;
            return;
        }
        int cl=++tot;
        a[cl]=a[q],a[cl].cnt=0,a[cl].len=a[p].len+1;
        a[cur].fa=a[q].fa=cl;
        while(a[p].nex[it]==q&&p)
            a[p].nex[it]=cl,p=a[p].fa;
        return;
    }
    void build()
    {
        for(int i=1;i<=tot;i++)
            add(a[i].fa,i);
        return;
    }
    LL ans=0;
    void DFS(int now)
    {
        for(int to,i=head[now];i;i=edge[i].nex)
        {
            to=edge[i].to;
            DFS(to);
            a[now].cnt+=a[to].cnt;
        }
        if(a[now].cnt!=1)
            ans=max(ans,1LL*a[now].cnt*a[now].len);
        return;
    }
}S;
//--------------------//
int main()
{
    scanf("%s",s+1);
    int len=strlen(s+1);
    for(int i=1;i<=len;i++)
        S.insert(s[i]);
    S.build();
    S.DFS(1);
    printf("%lld",S.ans);
    return 0;
}

参考资料

\(\mathcal{Alex\_Wei's\ Blog}\)

\(\mathcal{OI-Wiki}\)