后缀排序

后缀数组

一般可用于某一个字符串的子串有关字典序的问题。

算法流程

先对该字符串的所有后缀进行排序

定义：$sa[i]$ 表示将所有后缀排序后第 $i$ 小的后缀的编号。$rk[i]$ 表示后缀$i$ 的排名

采用倍增+基数排序($O(n\log n)$)，（如果偷懒/怕错也可以用快排($O(n\log^2 n )$)）

假设我们已经知道了长度为 $w$的子串的排名 $rk_w[1..n]$（即，$rk_w[i]$ 表示 $s[i..min(i+w−1,n)]$ 在 ${s[x..min(x+w−1,n)] x \in [1,n] }$ 中的排名），那么，以 $rk_w[i]$ 为第一关键字，$rk_w[i+w]$ 为第二关键字（若 $i+w>n$ 则令 $rk_w[i+w]$ 为无穷小）进行排序，就可以求出 $rk_{2w}[1..n]$。

关于基数排序，是对每一个关键词按优先级从大到小进行一次捅排序，复杂度和值域向关，于是把$O(n\log n)$一次的快排优化到了$O(n)$。

可以参考算法可视化进行理解

原始代码

scanf("%s", s + 1);
  n = strlen(s + 1);
  m = max(n, 300);
  //m表示值域大小
  for (i = 1; i <= n; ++i) ++cnt[rk[i] = s[i]];
  for (i = 1; i <= m; ++i) cnt[i] += cnt[i - 1];
  for (i = n; i >= 1; --i) sa[cnt[rk[i]]--] = i;
  for (w = 1; w < n; w <<= 1) {
    //按rk[i+w]第一次捅排，把排序结果存入id中
    memset(cnt, 0, sizeof(cnt));
    for (i = 1; i <= n; ++i) id[i] = sa[i];
    for (i = 1; i <= n; ++i) ++cnt[rk[id[i] + w]];
    for (i = 1; i <= m; ++i) cnt[i] += cnt[i - 1];
    for (i = n; i >= 1; --i) sa[cnt[rk[id[i] + w]]--] = id[i];
    //按rk[i]第二次捅排，把排序结果存入sa中
    memset(cnt, 0, sizeof(cnt));
    for (i = 1; i <= n; ++i) id[i] = sa[i];
    for (i = 1; i <= n; ++i) ++cnt[rk[id[i]]];
    for (i = 1; i <= m; ++i) cnt[i] += cnt[i - 1];
    for (i = n; i >= 1; --i) sa[cnt[rk[id[i]]]--] = id[i];
    /*
    以上两次桶排也可以转化为以下简介的快排
    bool paix(int x,int y){
		return rk[x] == rk[y] ? rk[x + w] < rk[y + w] : rk[x] < rk[y];
	}
    sort(sa + 1, sa + n + 1, paix)	
    */
    memcpy(oldrk, rk, sizeof(rk));
    //根据sa的值重新更新rk的值（因为把以前排名一致的更新）
    for (p = 0, i = 1; i <= n; ++i) {
      if (oldrk[sa[i]] == oldrk[sa[i - 1]] &&
          oldrk[sa[i] + w] == oldrk[sa[i - 1] + w]) {
        rk[sa[i]] = p;
      } else {
        rk[sa[i]] = ++p;
      }
    }
  }

优化：

不需要对$rk[i+w]$排序，因为你已经知道了$sa[1\sim n]$，只需要对$i+w$大于$n$的处理成无限小，剩下的第$i$名就是$sa[i]-p$。

值域范围可以更新，我们在最后一段其实求出了当前的值域范围$p$，用它更新$m$。

如果值域已经是$n$了，即$rk$已经互不相同，就可以结束

还有一些奇奇怪怪的卡常技巧（好像是连续访问一段内存会快一些）

总之，最后的代码如下

  int i, m = 300, p, w;
  scanf("%s", s + 1);
  n = strlen(s + 1);
  for (i = 1; i <= n; ++i) ++cnt[rk[i] = s[i]];
  for (i = 1; i <= m; ++i) cnt[i] += cnt[i - 1];
  for (i = n; i >= 1; --i) sa[cnt[rk[i]]--] = i;
  for (w = 1;; w <<= 1, m = p) {  // 优化二
    //优化一
    for (p = 0, i = n; i > n - w; --i) id[++p] = i;
    for (i = 1; i <= n; ++i)
      if (sa[i] > w) id[++p] = sa[i] - w;
    memset(cnt, 0, sizeof(cnt));
    //优化四
    for (i = 1; i <= n; ++i) ++cnt[px[i] = rk[id[i]]];
    for (i = 1; i <= m; ++i) cnt[i] += cnt[i - 1];
    for (i = n; i >= 1; --i) sa[cnt[px[i]]--] = id[i];
    memcpy(oldrk, rk, sizeof(rk));
    for (p = 0, i = 1; i <= n; ++i)
      //优化四
      rk[sa[i]] = cmp(sa[i], sa[i - 1], w) ? p : ++p;
    //优化三
    if (p == n) {
      for (int i = 1; i <= n; ++i) sa[rk[i]] = i;
      break;
    }
  }

运用

算法讲解到这，好像发现了一个问题：后缀数组的用途是不是有点少啊...好像只能处理个后缀的字典序，除此之外就没得用了...

其实，后缀数组真正有用的一个重要数组才刚刚上场

$hight$数组

定义：$height[i]=lcp(sa[i],sa[i−1])$，即第$i$名的后缀与它前一名的后缀的最长公共前缀。

想一想，这种定义有什么好处，或者说，这种定义能做到什么

我们之前费尽周折，好不容易才把所有的后缀拍了个序，见下图

我们以排名为6的这个后缀为例（假如我们已经求出了所有$hight$）我们想知道这个后缀与所有其它后缀的前缀有多少是相同的，怎么办呢？

首先它与排名为5的后缀有$hight[6]=2$个部分是相同的，与排名为4的后缀有1个部分是相同的，排名为4的有1个，排名为3的有0个，排名为2的也只有0个，发现，排名为$i$的前缀与$j$的前缀的公共部分就有$min_{j\le k\le i}\{hight[k]\}$（当$j> i$也类似），为什么呢？

可以想一想字典序的相关定义，$s_1$与$s_2$的字典序小，说明$s_1[1\sim i]$与$s_2[1\sim i]$是相同，而$s_1[i+1]$与$s_2[i+1]$不同，那么如果$height$ 一直大于某个数，前这么多位就一直没变过。如果小于了某个数$k$，那$s[k]$之后的就不可能会再一次与他重合了。

我们再想一想这$n$个后缀还有什么性质

在求出每个$hight$之后，我们其实是对$n$个后缀的相等信息进行了压缩，而$n$个后缀的每一个前缀，又能完整的表示所有子串，这对我们处理子串的相等问题也大有帮助！

这就是$hight$数组在后缀数组种的运用实质，下面我们考虑怎么求出$hight$数组（终于开始将求法了...）

假设现在我们想得到$hight[rk[i]]$（$hight[i]$表示的是$lcp(sa[i],sa[i−1])$），其实可以利用$hight[rk[i-1]]$，这里给出一个引理$height[rk[i]]≥height[rk[i−1]]−1$。

是不是看不懂，没关系，我们不用拘泥与这个式子，参考图想象一下。（下图中蓝色的一条和红色的一条表示后缀$i-1$和后缀$sa[rk[i-1]-1]$相等的部分）

可以发现，$hight[rk[i]]$其实已经有了一个“保底”，即黑色下划线和绿色下划线的部分一定是相等的，但你无法保证$sa[rk[i]-1]$就是$x+1$啊

其实没有关系，我们可以结合字典序考虑，如果现在有字符串$s_i$和$s_x$（$s_x<s_i$），而且已经有$s_i$与$s_x$前$y$个字符是相等的，那么一定不存在一个$s_j$使$s_x< s_j<s_i$且$s_j$与$s_i$相等的前缀长度小于$y$。

所以说，在你求$hight[rk[i]]$的时候，已经有了$hight[rk[i-1]]-1$的“保底”，后缀$sa[rk[i]-1]$与后缀$i$的前缀相同长度可以更长，但一定不会小于保底长度。

求$hight$的代码，就接在求出$sa$之后。

for (i = 1, k = 0; i <= n; ++i) {
  if (k) --k;
  while (s[i + k] == s[sa[rk[i] - 1] + k]) ++k;
  ht[rk[i]] = k;  // height太长了缩写为ht
}

这就是后缀数组的基本流程（还是比较好理解的吧...）

下面上一些经典的题目

咕咕咕。。。。。。。