初识SAM——后缀自动机

2022年01月20日，第七天

后缀自动机（SAM）

后缀自动机 是一个能解决许多字符串相关问题的有力数据结构。

以下的字符串问题都可以在线性的时间复杂度内通过 $SAM$ 解决。

• 在另一个字符串中搜索一个字符串的所有出现位置。
• 计算给定的字符串中有多少个不同的子串。

直观上，字符串的 $SAM$ 可以理解为给定字符串的所有子串的压缩形式。

一些保证线性的性质：

• 对于一个长度为 $n$ 的字符串 $s$ ，它的 $SAM$ 中的 状态数 不会超过 $2n-1$ （假设 $n\ge 2$）。
• 对于一个长度为 $n$ 的字符串 $s$ ，它的 $SAM$ 中的 转移数 不会超过 $3n-4$ （假设 $n\ge 3$）。

1. SAM 的定义

字符串 $s$ 的 $SAM$ 是一个接受 $s$ 的所有的最小 $DFA$ （确定性有限自动机或确定性有限状态自动机）。

换句话说：

• $SAM$ 是一张有向无环图。结点被称作 状态 ，边被称作状态间的 转移 。
• 图存在一个原点 $t_0$ ，称作 初始状态 ，其它各结点均可从 $t_0$ 出发到达。
• 每个 转移 都标有一些字母。从一个结点出发的所有转移均 不同 。
• 存在一个或多个 终止状态 。如果我们从初始状态 $t_0$ 出发，最终转移到了一个终止状态，则路径上的所有转移连接在起来一定是字符串 $s$ 的一个后缀。$s$ 的每个后缀均可用一条从 $t_0$ 到某个终止状态的路径构成。
• 在所有满足上述条件的自动机中，$SAM$ 的结点数是最少的。

2. 子串的性质

$SAM$ 最简单、也最重要的性质是，它包含关于字符串 $s$ 的所有子串的信息。任意从初始状态 $t_0$ 开始的路径，如果我们将转移路径上的标号写下来，都会形成 $s$ 的一个 子串 。反之每个 $s$ 的子串对应从 $t_0$ 开始的某条路径。

为了简化表达，我们称子串 对应 一条路径（从 $t_0$ 开始、由一些标号构成这个子串）。反过来，我们说任意一条路径 对应 它的标号构成的字符串。

到达某个状态的路径可能不止一条，因此我们说一个状态对应一些字符串的集合，这个集合的每个元素对应这些路径。

3. 构造 SAM（线性时间内构造）

在描述线性时间内构造 $SAM$ 的算法之前，我们需要引入几个对理解构造过程非常重要的概念并对其进行简单证明。

1. 结束位置 $endpos$

   考虑字符串 $s$ 的任意非空子串 $t$ ，我们记 $endpos(t)$ 为在字符串 $s$ 中 $t$ 的所有结束位置 (假设对字符串中字符的编号从零开始)。例如，对于字符串 $“abcbc”$ ，我们有 $endpos(“bc”)=2,4$ 。

   两个子串 $t_1$ 与 $t_2$ 的 $endpos$ 集合可能相等：$endpos(t_1)=endpos(t_2)$ 。这样所有字符串 $s$ 的非空子串都可以根据它们的 $endpos$ 集合被分为若干 等价类 。

   显然，$SAM$ 中的每个状态对应一个或多个 $endpos$ 相同的子串。换句话说，$SAM$ 中的状态数等于所有子串的等价类的个数，再加上初始状态。$SAM$ 的状态个数等价于 $endpos$ 相同的一个或多个子串所组成的集合的个数 $+1$ 。

   由 $endpos$ 的值我们可以得到一些重要结论：

   引理1：两个非空子串 $u$ 和 $w$ (假设 $|u|\le |w|$) 的 $endpos$ 相同，当且仅当字符串 $u$ 是 $w$ 的后缀。

   引理2：考虑两个非空子串 $u$ 和 $w$ (假设 $|u|\le |w|$)。那么要么 $endpos(u)\cap endpos(w)=\varnothing$ ，要么 $endpos(w)\subseteq endpos(u)$ ，取决于 $u$ 是否为 $w$ 的一个后缀：
   $$\{\begin{array}{l}\begin{array}{rlr}& endpos(w)\subseteq endpos(u)& ifuisasuffixofw\\ & endpos(w)\cap endpos(u)=\varnothing & otherwise\end{array}\end{array}$$

   引理3：考虑一个 $endpos$ 等价类，将类中的所有子串按长度非递增的顺序排序。每个子串都不会比它前一个子串长，于此同时每个子串也是它前一个子串的后缀。换句话说，对于同一等价类的任意两个子串，较短者为较长者的后缀，且该等价类中的字串长度恰好覆盖整个区间 $[x,y]$ 。

2. 后缀链接 $link$

   考虑 $SAM$ 中某个不是 $t_0$ 的状态 $v$ 。我们已经知道，状态 $v$ 对应于具有相同 $endpos$ 的等价类。我们如果定义 $w$ 为这些字符串中最长的一个，则所有其它的字符串都是 $w$ 的后缀。

   我们还知道字符串 $w$ 的前几个后缀（按长度降序考虑）全部包含于这个等价类，且所有其它后缀（至少有一个——空后缀）在其它的等价类中。我们记 $t$ 为最长的这样的后缀，然后将 $v$ 的后缀链接连到 $t$ 上。

   换句话说，一个 后缀链接 $link(v)$ 链接到对应于 $w$ 的最长后缀的另一个 $endpos$ 等价类的状态。

   以下我们假定初始状态 $t_0$ 对应于它自己这个等价类（只包含一个空字符串）。为了方便，我们规定 $endpos(t_0)=\{-1,0,\cdots ,|S|-1\}$ 。

   引理4：所有后缀链接构成一棵根结点为 $t_0$ 的树。

   引理5：通过 $endpos$ 集合构造的树（每个子节点的 $subset$ 都包含在父节点的 $subset$ 中）与通过后缀链接 $link$ 构造的数相同。

小结：在学习算法本身前，我们总结一下之前学过的知识，并引入一些辅助记号。

• $s$ 的子串可以根据它们结束的位置 $endpos$ 被划分为多个等价类。

• $SAM$ 由初始状态 $t_0$ 和与每一个 $endpos$ 等价类对应的每个状态组成。

• 对于每一个状态 $v$ ，一个或多个子串与之匹配。我们记 $longest(v)$ 为其中最长的一个字符串，记 $maxlength(v)$ 为它的长度。类似地，记 $shortest(v)$ 为最短的子串，它的长度为 $minlength(v)$ 。那么对应这个状态的所有字符串都是字符串 $longest(v)$ 的不同的后缀，且所有字符串的长度恰好覆盖区间 $[minlength(v),maxlength(v)]$ 中的每一个整数。

• 对于任意不是 $t_0$ 的状态 $v$ ，定义后缀链接为连接到对应字符串 $longest(v)$ 的长度为 $minlength(v)-1$ 的后缀的一条边。从根节点 $t_0$ 出发的后缀链接可以形成一棵树。这棵树也表示 $endpos$ 集合间的包含关系。

• 对于 $t_0$ 以外的状态 $v$ ，可用后缀链接 $link(v)$ 表达 $minlength(v)$ ：
  $$minlength(v)=maxlength(link(v))+1$$

• 如果我们从任意状态 $v_0$ 开始顺着后缀链接遍历，总会到达初始状态 $t_0$ 。这种情况下我们可以得到一个互不相交的区间 $[minlength(v_i),maxlength(v_i)]$ 的序列，且它们的并集形成了连续的区间 $[0,maxlength(v_0)]$ 。

4. 实现过程

$SAM$ 有 $O(|S|)$ 的构造方法，为了实现 $O(|S|)$ 的构造，对于每个状态肯定不能保存太多数据，例如 $substr(state)$ 肯定无法保存下来。

对于状态 $state$ 我们只保存如下数据:

• $maxlen[state]$ ，$state$ 包含的最长子串的长度。
• $minlen[state]$ ，$state$ 包含的最短子串的长度。
• $ch[state][1\cdots c]$ ，$state$ 的转移函数，$c$ 为字符集的大小
• $link[state]$ ，$state$ 的后缀链接

在该方法中，使用 增量法 构造 $SAM$ ，从初始状态开始，每次考虑添加一个字符 $S[1],S[2],\cdots ,S[N]$，依次构造可以识别 $S[1],S[1\cdots 2],S[1\cdots 3],\cdots ,S[1\cdots N]$ 的 $SAM$ 。

假设已经构造好了 $S[1\cdots i]$ 的 $SAM$ ，要添加字符 $S[i+1]$ ，相当于新增了 $i+1$ 个 $S[i+1]$ 的后缀要识别，分别为：$S[1\cdots i+1],S[2\cdots i+1],\cdots ,S[i\cdots i+1],S[i+1]$ 。

这些新增状态分别是从 $S[1\cdots i],S[2\cdots i],S[3\cdots i],S[i],\_$(空串) 通过字符 $S[i+1]$ 转移过来的。

假设 $S[1\cdots i]$ 所在的状态是 $u$ ，即：$S[1\cdots i]\in substr(u)$ ，$S[1\cdots i],S[2\cdots i],S[3\cdots i],\cdots ,S[i],\_$(空串) 对应的状态恰好是从 $u$ 到初始状态 $S$ 的由 后缀链接 连接起来路径上的所有状态，不妨称这条路径上所有状态集合是 $suffix\_path(u\to S)$ ，显然至少 $S[1\cdots i+1]$ 不能被以前的 $SAM$ 识别，所以我们至少需要添加一个状态 $z$ ，$z$ 至少包含 $S[1\cdots i+1]$ 。

情况一 ：对于 $suffix\_path(u\to S)$ 的任意状态 $v$ ，都有 $ch[v][S[i+1]]=NULL$ 。

这时我们只要令 $ch[v][S[i+1]]=z$ ，并且令 $link[z]=S$ (这里的 $S$ 表示源点)即可。

情况二：$suffix\_path(u\to S)$ 上存在结点 $v$ ，满足 $ch[v][S[i+1]]\ne NULL$ 。

我们可以认为在 $suffix\_path(u\to S)$ 遇到的第一个状态 $v$ 满足 $ch[v][S[i+1]]=x$ 。这时讨论 $x$ 包含的子串的情况，分为 $A,B$ 两类：

• $A$ 类：$x$ 中包含的最长子串就是 $v$ 中包含的最长字串接上字符 $S[i+1]$ ，即$maxlen(v)+1=maxlen(x)$ ，$z$ 的后缀链接恰好是 $x$ 。若在 $suffix\_path(u\to S)$ 上 $v$ 从 $pre\_v$ 转移，则 $maxlen(x)=maxlen(v)+1=minlen(pre\_v)=minlen(z)-1$ 。

  此时只要增加 $link[z]=x$ 即可。既然 $x$ 存在，那么 $x$ 的后缀一定也存在，本次增量完成。

• $B$ 类：$x$ 中包含的最长字串不是 $v$ 中包含的最长字串接上字符 $S[i+1]$ ，即 $maxlen(v)+1<maxlen(x)$ 。这种情况下增加的字符是 $c$ ，状态是 $z$ 。在 $suffix\_path(u\to S)$ 这条路径上，从 $u$ 开始有一部分连续的状态满足 $ch[u\cdots ][c]=z$ ，紧接着有一部分连续的状态 $v\cdots w$ 满足 $ch[v\cdots w][c]=x$ ，并且 $maxsub(v)+c$ 不等于 $maxsub(x)$ 。

  此时只要从 $x$ 拆分出新的状态 $y$ ，并且把原来 $x$ 中长度小于等于 $maxsub(v)+c$ 的子串分给 $y$ ，其余子串留给 $x$ 。同时令 $ch[v\cdots w][c]=y,link[y]=link[x],link[x]=link[z]=y$ 。也就是 $y$ 先继承 $x$ 的 $link$ ，并且 $x,z$ 前面断开的 $substrings$ 就存在于 $y$ 中了。

  由此产生了以下短小精悍的代码QwQ：

const int N = 1e6 + 5;
struct node {
    int len, link, ch[26];
}st[N << 1];
int sz, last;

void sam_init () { sz = last = 1; }   // 为方便操作，这里我们从 1 开始

void sam_extend (int c) {
    int cur = ++ sz, p = last;
    last = cur, st[cur].len = st[p].len + 1;
    for ( ; p && ! st[p].ch[c]; p = st[p].link) st[p].ch[c] = cur;
    if (p == 0) st[cur].link = 1;   // 情况一
    else {
        int q = st[p].ch[c];
        if (st[p].len + 1 == st[q].len) st[cur].link = q;   // 情况二 A类
        else {			// 情况二 B类
            int clone = ++ sz;
            st[clone].len = st[p].len + 1;
            st[clone].link = st[q].link;
            memcpy (st[clone].ch, st[q].ch, sizeof (int)*26);
            for ( ; p && st[p].ch[c] == q; p = st[p].link) st[p].ch[c] = clone;
            st[q].link = st[cur].link = clone;
        }
    }
}

5. SAM 的应用（施工中）

1. 检查字符串是否出现
2. 不同子串的个数
3. 所有不同子串的总长度
4. 字典序第 $k$ 大子串
5. 最小循环位移
6. 出现次数
7. 第一次出现位置
8. 所有出现的位置
9. 最短的没有出现的字符串
10. 两个字符串的最长公共子串
11. 多个字符串间的最长公共子串