后缀自动机 (SAM)

一些前置约定/定义¶

记为字符集，为字符集大小。对于一个字符串，记为其长度。

后缀自动机概述¶

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

举个例子，以下的字符串问题都可以在线性时间内通过 SAM 解决。

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

直观上，字符串的 SAM 可以理解为给定字符串的 所有子串 的压缩形式。值得注意的事实是，SAM 将所有的这些信息以高度压缩的形式储存。对于一个长度为的字符串，它的空间复杂度仅为。此外，构造 SAM 的时间复杂度仅为。准确地说，一个 SAM 最多有个节点和条转移边。

SAM 的定义¶

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

换句话说：

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

子串的性质¶

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

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

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

构造 SAM¶

我们将会在这里展示一些简单的字符串的后缀自动机。

我们用蓝色表示初始状态，用绿色表示终止状态。

对于字符串：

在线性时间内构造 SAM¶

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

结束位置 `endpos`¶

考虑字符串的任意非空子串，我们记为在字符串中的所有结束位置（假设对字符串中字符的编号从零开始）。例如，对于字符串，我们有。

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

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

我们稍后将会用这个假设来介绍构造 SAM 的算法。我们将发现，SAM 需要满足的所有性质，除了最小性以外都满足了。由 Nerode 定理我们可以得出最小性（不会在这篇文章中证明）。

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

引理 1： 字符串的两个非空子串和（假设）的相同，当且仅当字符串在中的每次出现，都是以后缀的形式存在的。

引理显然成立。如果和的相同，则是的一个后缀，且只以中的一个的后缀的形式出现。且根据定义，如果为的一个后缀，且只以后缀的形式在中出现时，两个子串的相同。

引理 2： 考虑两个非空子串和（假设）。那么要么，要么，取决于是否为的一个后缀：

证明：如果集合与有至少一个公共元素，那么由于字符串与在相同位置结束，是的一个后缀。所以在每次出现的位置，子串也会出现。所以。

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

证明：如果等价类中只包含一个子串，引理显然成立。现在我们来讨论子串元素个数大于的等价类。

由引理 1，两个不同的等价的字符串中，较短者总是较长者的真后缀。因此，等价类中没有等长的字符串。

记为等价类中最长的字符串、为等价类中最短的字符串。由引理 1，字符串是字符串的真后缀。现在考虑长度在区间中的的任意后缀。容易看出，这个后缀也在同一等价类中，因为这个后缀只能在字符串中以的一个后缀的形式存在（也因为较短的后缀在中只以的后缀的形式存在）。因此，由引理 1，这个后缀和字符串的相同。

后缀链接 `link`¶

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

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

换句话说，一个 后缀链接 连接到对应于的最长后缀的另一个等价类的状态。

以下我们假设初始状态对应于它自己这个等价类（只包含一个空字符串）。为了方便，我们规定。

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

证明：考虑任意不是的状态，后缀链接连接到的状态对应于严格更短的字符串（后缀链接的定义、引理 3）。因此，沿后缀链接移动，我们总是能到达对应空串的初始状态。

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

证明：由引理 2，任意一个 SAM 的集合形成了一棵树（因为两个集合要么完全没有交集要么其中一个是另一个的子集）。

我们现在考虑任意不是的状态及后缀链接，由后缀链接和引理 2，我们可以得到

结合前面的引理有：后缀链接构成的树本质上是集合构成的一棵树。

以下是对字符串构造 SAM 时产生的后缀链接树的一个例子，节点被标记为对应等价类中最长的子串。

小结¶

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

的子串可以根据它们结束的位置被划分为多个等价类；
SAM 由初始状态和与每一个等价类对应的每个状态组成；
对于每一个状态，一个或多个子串与之匹配。我们记为其中最长的一个字符串，记为它的长度。类似地，记为最短的子串，它的长度为。那么对应这个状态的所有字符串都是字符串的不同的后缀，且所有字符串的长度恰好覆盖区间中的每一个整数。
对于任意不是的状态，定义后缀链接为连接到对应字符串的长度为的后缀的一条边。从根节点出发的后缀链接可以形成一棵树。这棵树也表示集合间的包含关系。
对于以外的状态，可用后缀链接表达：

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

算法¶

现在我们可以学习构造 SAM 的算法了。这个算法是在线算法，我们可以逐个加入字符串中的每个字符，并且在每一步中对应地维护 SAM。

为了保证线性的空间复杂度，我们将只保存和的值和每个状态的转移列表，我们不会标记终止状态（但是我们稍后会展示在构造 SAM 后如何分配这些标记）。

一开始 SAM 只包含一个状态，编号为（其它状态的编号为）。为了方便，对于状态我们指定、（表示虚拟状态）。

现在，任务转化为实现给当前字符串添加一个字符的过程。算法流程如下：

令为添加字符之前，整个字符串对应的状态（一开始我们设，算法的最后一步更新）。
创建一个新的状态，并将赋值为，在这时的值还未知。
现在我们按以下流程进行（从状态开始）。如果还没有到字符的转移，我们就添加一个到状态的转移，遍历后缀链接。如果在某个点已经存在到字符的转移，我们就停下来，并将这个状态标记为。
如果没有找到这样的状态，我们就到达了虚拟状态，我们将赋值为并退出。
假设现在我们找到了一个状态，其可以通过字符转移。我们将转移到的状态标记为。
现在我们分类讨论两种状态，要么，要么不是。
如果，我们只要将赋值为并退出。
否则就会有些复杂。需要复制状态：我们创建一个新的状态，复制的除了的值以外的所有信息（后缀链接和转移）。我们将赋值为。
复制之后，我们将后缀链接从指向，也从指向。
最终我们需要使用后缀链接从状态往回走，只要存在一条通过到状态的转移，就将该转移重定向到状态。
以上三种情况，在完成这个过程之后，我们将的值更新为状态。

如果我们还想知道哪些状态是 终止状态 而哪些不是，我们可以在为字符串构造完完整的 SAM 后找到所有的终止状态。为此，我们从对应整个字符串的状态（存储在变量中），遍历它的后缀链接，直到到达初始状态。我们将所有遍历到的节点都标记为终止节点。容易理解这样做我们会准确地标记字符串的所有后缀，这些状态都是终止状态。

在下一部分，我们将详细叙述算法每一步的细节，并证明它的 正确性 。因为我们只为的每个字符创建一个或两个新状态，所以 SAM 只包含 线性个 状态。

而线性规模的转移个数，以及算法总体的线性运行时间还不那么清楚。

正确性证明¶

若一个转移满足，则我们称这个转移是 连续的 。否则，即当时，这个转移被称为 不连续的 。从算法描述中可以看出，连续的、不连续的转移是算法的不同情况。连续的转移是固定的，我们不会再改变了。与此相反，当向字符串中插入一个新的字符时，不连续的转移可能会改变（转移边的端点可能会改变）。
为了避免引起歧义，我们记向 SAM 中插入当前字符之前的字符串为。
算法从创建一个新状态开始，对应于整个字符串。我们创建一个新的节点的原因很清楚。与此同时我们也创建了一个新的字符和一个新的等价类。
在创建一个新的状态之后，我们会从对应整个字符串的状态通过后缀链接进行遍历。对于每一个状态，我们尝试添加一个通过字符到新状态的转移。然而我们只能添加与原有转移不冲突的转移。因此我们只要找到已存在的的转移，我们就必须停止。
最简单的情况是我们到达了虚拟状态，这意味着我们为所有的后缀添加了的转移。这也意味着，字符从未在字符串中出现过。因此的后缀链接为状态。
第二种情况下，我们找到了现有的转移。这意味着我们尝试向自动机内添加一个 已经存在的 字符串（其中为的一个后缀，且字符串已经作为的一个子串出现过了）。因为我们假设字符串的自动机的构造是正确的，我们不应该在这里添加一个新的转移。然而，难点在于，从状态出发的后缀链接应该连接到哪个状态呢？我们要把后缀链接连到一个状态上，且其中最长的一个字符串恰好是，即这个状态的应该是。然而还不存在这样的状态，即。这种情况下，我们必须通过拆开状态来创建一个这样的状态。
如果转移是连续的，那么。在这种情况下一切都很简单。我们只需要将的后缀链接指向状态。
否则转移是不连续的，即，这意味着状态不只对应于长度为的后缀，还对应于的更长的子串。除了将状态拆成两个子状态以外我们别无他法，所以第一个子状态的长度就是了。
我们如何拆开一个状态呢？我们复制状态，产生一个状态，我们将赋值为。由于我们不想改变遍历到的路径，我们将的所有转移复制到。我们也将从出发的后缀链接设置为的后缀链接的目标，并设置的后缀链接为。
在拆开状态后，我们将从出发的后缀链接设置为。
最后一步我们将一些到转移重定向到。我们需要修改哪些转移呢？只重定向相当于所有字符串（其中是的最长字符串）的后缀就够了。即，我们需要继续沿着后缀链接遍历，从结点直到虚拟状态或者是转移到不是状态的一个转移。

对操作次数为线性的证明¶

首先我们假设字符集大小为常数。如果字符集大小不是常数，SAM 的时间复杂度就不是线性的。从一个结点出发的转移存储在支持快速查询和插入的平衡树中。因此如果我们记为字符集，为字符集大小，则算法的渐进时间复杂度为，空间复杂度为。然而如果字符集足够小，可以不写平衡树，以空间换时间将每个结点的转移存储为长度为的数组（用于快速查询）和链表（用于快速遍历所有可用关键字）。这样算法的时间复杂度为，空间复杂度为。

所以我们将认为字符集的大小为常数，即每次对一个字符搜索转移、添加转移、查找下一个转移。这些操作的时间复杂度都为。

如果我们考虑算法的各个部分，算法中有三处时间复杂度不明显是线性的：

第一处是遍历所有状态的后缀链接，添加字符的转移。
第二处是当状态被复制到一个新的状态时复制转移的过程。
第三处是修改指向的转移，将它们重定向到的过程。

我们使用 SAM 的大小（状态数和转移数）为 线性的 的事实（对状态数是线性的的证明就是算法本身，对转移数为线性的的证明将在稍后实现算法后给出）。

因此上述 第一处和第二处 的总复杂度显然为线性的，因为单次操作均摊只为自动机添加了一个新转移。

还需为 第三处 估计总复杂度，我们将最初指向的转移重定向到。我们记，这是一个字符串的后缀，每次迭代长度都递减——因为字符串的位置每次迭代都单调上升。这种情况下，如果在循环的第一次迭代之前，相对应的字符串在距离的深度为的位置上（深度记为后缀链接的数量），那么在最后一次迭代后，字符串将会成为路径上第二个从出发的后缀链接（它将会成为新的的值）。

因此，循环中的每次迭代都会使作为当前字符串的后缀的字符串的位置单调递增。因此这个循环最多不会执行超过次迭代，这正是我们需要证明的。

实现¶

首先，我们实现一种存储一个转移的全部信息的数据结构。如果需要的话，你可以在这里加入一个终止标记，也可以是一些其它信息。我们将用一个 map 存储转移的列表，允许我们在总计的空间复杂度和的时间复杂度内处理整个字符串。（注：在字符集大小为较小的常数，比如 26 时，将 next 定义为 int[26] 更方便）

struct state {
  int len, link;
  std::map<char, int> next;
};

SAM 本身将会存储在一个 state 结构体数组中。我们记录当前自动机的大小 sz 和变量 last ，当前整个字符串对应的状态。

const int MAXLEN = 100000;
state st[MAXLEN * 2];
int sz, last;

我们定义一个函数来初始化 SAM（创建一个只有初始状态的 SAM）。

void sam_init() {
  st[0].len = 0;
  st[0].link = -1;
  sz++;
  last = 0;
}

最终我们给出主函数的实现：给当前行末增加一个字符，对应地在之前的基础上建造自动机。

void sam_extend(char c) {
  int cur = sz++;
  st[cur].len = st[last].len + 1;
  int p = last;
  while (p != -1 && !st[p].next.count(c)) {
    st[p].next[c] = cur;
    p = st[p].link;
  }
  if (p == -1) {
    st[cur].link = 0;
  } else {
    int q = st[p].next[c];
    if (st[p].len + 1 == st[q].len) {
      st[cur].link = q;
    } else {
      int clone = sz++;
      st[clone].len = st[p].len + 1;
      st[clone].next = st[q].next;
      st[clone].link = st[q].link;
      while (p != -1 && st[p].next[c] == q) {
        st[p].next[c] = clone;
        p = st[p].link;
      }
      st[q].link = st[cur].link = clone;
    }
  }
  last = cur;
}

正如之前提到的一样，如果你用内存换时间（空间复杂度为，其中为字符集大小），你可以在的时间内构造字符集大小任意的 SAM。但是这样你需要为每一个状态储存一个大小为的数组（用于快速跳转到转移的字符），和另外一个所有转移的链表（用于快速在转移中迭代）。

应用¶

下面我们来看一些可以用 SAM 解决的问题。简单起见，假设字符集的大小为常数。这允许我们认为增加一个字符和遍历的复杂度为常数。

检查字符串是否出现¶

给一个文本串和多个模式串，我们要检查字符串是否作为的一个子串出现。

我们在的时间内对文本串构造后缀自动机。为了检查模式串是否在中出现，我们沿转移（边）从开始根据的字符进行转移。如果在某个点无法转移下去，则模式串不是的一个子串。如果我们能够这样处理完整个字符串，那么模式串在

后缀自动机 (SAM)

一些前置约定/定义¶

后缀自动机概述¶

SAM 的定义¶

子串的性质¶

构造 SAM¶

在线性时间内构造 SAM¶

结束位置 `endpos`¶

后缀链接 `link`¶

小结¶

算法¶

正确性证明¶

对操作次数为线性的证明¶

实现¶

更多性质¶

状态数¶

转移数¶

额外信息¶

应用¶

检查字符串是否出现¶

后缀自动机 (SAM)

一些前置约定/定义¶

后缀自动机概述¶

SAM 的定义¶

子串的性质¶

构造 SAM¶

在线性时间内构造 SAM¶

结束位置 endpos¶

后缀链接 link¶

小结¶

算法¶

正确性证明¶

对操作次数为线性的证明¶

实现¶

更多性质¶

状态数¶

转移数¶

额外信息¶

应用¶

检查字符串是否出现¶

结束位置 `endpos`¶

后缀链接 `link`¶