字符串

字符串

大多数字符串介绍算法的关键：

运用自动机的思想寻找限制条件下的状态转移函数，使得可以借助之前的状态来加速计算新的状态，比如：

• KMP算法
• Z函数（扩展KMP）
• BM算法

---

字符串基础

参考文献：$[1]$ https://oi-wiki.org/string/basic/

---

字符串匹配

哈希算法、KMP算法、暴力算法$O(nm)$

---

字符串哈希

• 思想

思想就是将不同的字符串映射为不同的哈希值，这样字符串匹配的时候直接判断字符串对应的哈希值是否一样就可以了。

• 方法

而方法通常是将长度为一个字符串$s$的哈希值看成一个$b$进制的数对$M$取模的结果s，利用公式：
$$f(s)=\sum _{i=1}^{j}s[i]\times b^{l-i}(modM)$$
其中一般选$M$为一个大质数，当$b$和$M$互质时，出错概率为$\frac{1}{M}$，可以选取两个大质数分别求以减小错误率。

例如字符串$xyz$的哈希函数值为$x{b}^2+yb+z$。

• 应用

字符串匹配，最长回文子串，确定字符串中不同子字符串的数量

---

字典树

• 思想

思想是该字典树的边表示字母，根结点到树上某一结点的路径就代表一个字符串，记录$\delta (u,c)$表示结点$u$的$c$字符指向的下一个结点。

基本功能就是插入字符串和查找字符串

• 代码

struct trie {  
  int nex[100000][26], cnt;  
  bool exist[100000];  // 该结点结尾的字符串是否存在  
  
  void insert(char *s, int l) {  // 插入字符串  
    int p = 0;  
    for (int i = 0; i < l; i++) {  
      int c = s[i] - 'a';  
      if (!nex[p][c]) nex[p][c] = ++cnt;  // 如果没有，就添加结点  
      p = nex[p][c];  
    }  
    exist[p] = 1;  
  }  
  bool find(char *s, int l) {  // 查找字符串  
    int p = 0;  
    for (int i = 0; i < l; i++) {  
      int c = s[i] - 'a';  
      if (!nex[p][c]) return 0;  
      p = nex[p][c];  
    }  
    return exist[p];  
  }  
};  

• 拓展—$01-trie$

$01-trie$是指字符集为 { 0 , 1 } \{0,1\} {0,1}的$trie$。$01-trie$可以用来维护一些数字的异或和。

---

前缀函数

对于一个字符串$s$，其前缀函数$\pi [i]$表示子串$s[0...i]$最长的相等的真前缀与真后缀的长度。（也可以理解为$\pi [i]$为右端点在$i$且同时为一个前缀的最长真子串的长度）

• 计算方法

朴素算法$O(n^3)$，优化后的算法$O(n)$

• 举例

举例来说，对于字符串abcabcd，

$\pi [0]=0$，因为 a 没有真前缀和真后缀，根据规定为 0

$\pi [1]=0$，因为 ab 无相等的真前缀和真后缀

$\pi [2]=0$，因为 abc 无相等的真前缀和真后缀

$\pi [3]=1$，因为 abca 只有一对相等的真前缀和真后缀a，长度为 1

$\pi [4]=2$，因为 abcab 相等的真前缀和真后缀只有 ab，长度为 2

$\pi [5]=3$，因为 abcabc 相等的真前缀和真后缀只有 abc，长度为 3

$\pi [6]=0$，因为 abcabcd 无相等的真前缀和真后缀

同理可以计算字符串 aabaaab 的前缀函数为$[0,1,0,1,2,2,3]$。

• 应用

1. KMP算法

假如给定一个文本$t$和一个字符串$s$ ，我们尝试找到并展示$s$在$t$中的所有出现$（occurrence）$，假设$s$长度为$n$，$t$长度为$m$，则创建字符串$s+\#+t$，求该字符串的前缀函数，这样对于$i>n+1$的部分，其前缀函数$\pi [i]=n$就表示字符串$s$在字符串$t$的$i-2n$位置处出现了一次，遍历满足这个的$\pi [i]$的个数就是答案。同时在这种情况下意味着只需要存储字符串$s+\#$ 以及相应的前缀函数值即可，我们可以一次读入字符串$t$ 的一个字符并计算当前位置的前缀函数值。时间：$O(n+m)$，内存：$O(n)$。

2. 求字符串周期

3. 统计每个前缀出现次数

4. 找出一个字符串中本质不同子串的数目

5. 字符串压缩

假如给定一个字符串$s$，希望找到其最短的“压缩”表示，也就是找到一个最短的字符串$t$，使得$s$可以被$t$的一份或者多分拷贝的拼接表示。

显然，我们只需要找到$t$的长度即可。知道了该长度，该问题的答案即为长度为该值的$s$的前缀。

计算字符串$s$的前缀函数，定义$k=n-\pi [n-1]$，其中$n$为$s$的长度，$\pi [n-1]$表示字符串$s$前缀函数的最后一个值。如果$k$能整除$n$，那么$k$就是答案，否则不存在一个有效的压缩，即答案为$n$。

---

BM算法

$BM$算法是比$KMP$算法更高效的字符串匹配算法。其基本思想是通过后缀匹配获得比前缀匹配更多的信息来实现更快的字符跳转。（而$KMP$利用的是前缀匹配）

$BM$算法规则${}^{[2]}$：

• “坏字符规则”：后移位数=坏字符的位置-搜索词中的上一次出现的位置

  注：如果”坏字符”不包含在搜索词之中，则上一次出现位置为 -1，搜索词从0开始编号。

• “好后缀规则”：后移位数 = 好后缀的位置 - 搜索词中的上一次出现位置

  注：计算时，位置的取值以”好后缀”的最后一个字符为准。如果”好后缀”在搜索词中没有重复出现，则它的上一次出现位置为 -1，搜索词从0开始编号。

Boyer-Moore算法的基本思想是，每次后移这两个规则之中的较大值。

• 参考文献：

  $[2]$ https://blog.csdn.net/zhang0558/article/details/50187083
  $[3]$ https://blog.csdn.net/qpzkobe/article/details/80716922?ops_request_misc=%7B%22request%5Fid%22%3A%22161372740816780265476333%22%2C%22scm%22%3A%2220140713.130102334..%22%7D&request_id=161372740816780265476333&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~baidu_landing_v2~default-1-80716922.pc_search_result_hbase_insert&utm_term=Boyer-Moore算法

---

Z函数（扩展KMP）

• 定义

对于长度为$n$的字符串$s$，定义函数$z[i]$表示$s$和$s[i,n-1]$（即以$s[i]$开头的后缀）的最长公共前缀（$LCP$）的长度。$z$被称为$s$的$z$函数。特别地，$z[0]=0$；同时约定：字符串下标以$0$为起点。

• $Z$函数求解算法

  • 朴素算法$O(n^2)$

  • 线性算法$O(n)$：

    思想就是：维护一个右端点最靠右的匹配段$[l,r]$（这里对于$i$，我们称区间 $[i,i+z[i]-1]$是$i$的 匹配段，也可以叫 Z-box），从$1$到$n-1$顺次计算$z[i]$的值，根据$i$和$r$的关系进行状态转移。

• 应用

  • 匹配所有子串$O(|t|+|p|)$：与$KMP$类似，创造字符串$s=p+\#+t$，此时计算$s$的$Z$函数。
  • 本质不同子串数：字符串本质不同代表字符串长度不一样或者长度相同但某些位不同
  • 字符串最小整周期：给定长度为$n$的字符串，$s$计算$s$的$Z$函数，则其最小整周期的长度为满足$i+z[i]=n$的最小的$n$的因数$i$。

---

自动机

• $OI$中所说的“自动机”一般都指“确定有限状态自动机”。
• 自动机是一个对信号序列进行判定的数学模型。（可以抽象成一个有向图，自动机的每一个结点都是一个判定结点，是一个状态。）
• 形式化定义（**确定有限状态自动机（DFA）**由以下五个部分构成）${}^{[3]}$：
  • 字符集（$\sum$）:该自动机只能输入这些字符。
  • 状态集合（$Q$）：如果把一个$DFA$看成一张有向图，那么$DFA$中的状态就相当于图上的顶点。
  • 起始状态（$start$）：$start\in Q$，是起始的状态。
  • 接受状态集合（$F$）：$FQ\subseteq Q$，表示可以被接受的状态的集合
  • 转移函数（$\delta$）：$\delta$是一个接受两个参数返回一个值的函数，其中第一个参数和返回值都是一个状态，第二个参数是字符集中的一个字符。如果把一个$DFA$看成一张有向图，那么$DFA$中的转移函数就相当于顶点间的边，而每条边上都有一个字符。

用一句话概括就是：自动机就是通过转移函数，对输入的信号序列进行判定和状态转移的数学模型。

• 常用的自动机
  • 字典树
  • $KMP$自动机
  • $AC$自动机
  • 后缀自动机
  • 广义后缀自动机
  • 回文自动机
  • 序列自动机

参考文献：$[4]$ https://oi-wiki.org/string/automaton/#_2

---

$AC$自动机

AC 自动机是以字典树（$Trie$）的结构为基础，结合KMP的思想建立的。

• 思想

简单来说，建立一个$AC$自动机有两个步骤：

1. 基础的$Trie$结构：将所有的模式串构成一棵$Trie$。
2. $KMP$的思想：对$Trie$树上所有的结点构造失配指针。
   状态 $u$的$fail$指针指向另一个状态$v$，其中$v\in Q$，且$v$是$u$的最长后缀（即在若干个后缀状态中取最长的一个作为$fail$指针）。

• 构建${}^{[5]}$

  • 字典树构建：将若干模式串构建一颗字典树$(Trie)$

  • 构建实配指针($fail$指针)：

    考虑字典树中当前的结点$u$，$u$的父结点是$p$，$p$通过字符c的边指向$u$，即$trie[p,c]=u$。假设深度小于$u$的所有结点的$fail$指针都已求得。

    1. 如果$trie[fail[p],c]$存在：则让$u$的$fail$指针指向$trie[fail[p],c]$。相当于在$p$和$fail[p]$后面加一个字符c，分别对应$u$和$fail[u]$。
    2. 如果$trie[fail[p],c]$不存在：那么我们继续找到$trie[fail[fail[p]],c]$。重复$1$的判断过程，一直跳$fail$指针直到根结点。
    3. 如果真的没有，就让$fail$指针指向根结点。

    如此即完成了$fail[u]$的构建。

• 例子${}^{[5]}$

  对字符串 i he his she hers 组成的字典树构建$fail$指针：

  1. 黄色结点：当前的结点$u$。
  2. 绿色结点：表示已经$BFS$遍历完毕的结点。
  3. 橙色的边：$fail$指针。
  4. 红色的边：当前求出的$fail$指针。

参考文献：$[5]$ https://oi-wiki.org/string/ac-automaton/

• 应用

多模匹配算法，能在一个文本串中同时查找多个不同的模式串，是$KMP$的升级版。（$KMP$是单模匹配算法，处理在一个文本串中查找一个模式串的问题）

---

后缀数组（$SA$）

后缀数组（$SuffixArray$）主要是两个数组：$sa$和$rk$。

其中，$sa[i]$表示将所有后缀排序后第$i$小的后缀的编号；$rk[i]$表示后缀$i$的排名。因此，这两个数组满足性质：$sa[rk[i]]=rk[sa[i]]=i$。

• 方法
  • $O(n^{2}logn)$：普通方法，$String+sort$。
  • $O(nlo{g}^{2}n)$：倍增思想，利用$sort(nlogn)$进行排序。
  • $O(nlogn)$：倍增思想，利用计数排序、基数排序进行优化排序
    • 计数排序${}^{[6]}$：$(O(n))$，该排序算法不是基于元素比较，而是利用下标来确定元素的正确位置，适用于取值范围不大的情况。两种不适用的情况：一是当数列最大值和最小值差距过大；二是当数列元素不是整数。
    • 基数排序：$(O(kn))$($k$表示分成的关键词的个数，对于数来说就是最大的数的位数)对元素进行“分类” ，先看最低位，进行排序，之后看到时第二位进行排序，一直到最高位，排序后就是最终的排序。
  • $O(n)$：诱导排序与 SA-IS 算法。

参考文献：

$[6]$ https://www.sohu.com/a/258222713_684445

• 应用

  • 寻找最小的循环移动位置：将字符串$S$复制一份变成$SS$就转化成了后缀排序问题。

  • 在字符串中找子串：

    任务是：在线地在主串$T$中寻找模式串$S$，也就是，预先知道主串$T$，但是当且仅当询问时才知道模式串$S$。

    步骤：先构造主串$T$的后缀数组，然后查找子串$S$。这里假设子串$S$长度为$n$，由于子串$S$在$T$中出现，它必定是$T$的一些后缀的前缀，又由于$sa[i]$中根据$i$从$1$到$n$，$sa[i]$表示的就是从小到大的主串$T$的后缀字符串的第一个字符的位置，因此，利用二分法二分$sa[i]$（时间复杂度$O(|T|)$），比较子串$s$与当前后缀的大小（时间复杂度$O(n)$），因此总的时间复杂度为$O(nlog|T|)$。注意，如果该子串在$T$中出现了多次，每次出现都是在$sa$数组中相邻的。因此出现次数可以通过再次二分找到，输出每次出现的位置也很轻松。

  • 从字符串首尾取字符最小化字典序

• $height$数组

  • $LCP$（最长公共前缀）：两个字符串$S$和$T$的$LCP$，就是最大的$x$（$x\le min(|S|,|T|)$）使得$S_i=T_i(\forall 1\le i\le x)$。后面以$lcp(i,j)$表示后缀$i$和后缀$j$的最长公共前缀（的长度）。

  • $height$数组的定义：$height[i]=lcp(sa[i],sa[i-1])$，即第$i$名的后缀与它前一名的后缀的最长公共前缀。$height[1]$可以视作$0$。

  • 求$height$数组：$O(n)$。

  • 应用

    • 求两子串的最长公共前缀： l c p ( s a [ i ] , s a [ j ] ) = m i n { h e i g h t [ i + 1.. j ] } lcp(sa[i],sa[j])=min\{height[i+1..j]\} lcp(sa[i],sa[j])=min{height[i+1..j]}。

    • 比较一个字符串的两个子串的大小关系：

      假设需要比较的是$A=S[a..b]$和$B=S[c..d]$的大小关系。若$lcp(a,c)\ge min(|A|,|B|),A<B⟺|A|<|B|$。否则，$A<B⟺rk[a]<rk[c]$。

    • 不同子串的数目：$\frac{n(n+1)}{2}-{\sum }_{i=2}^{n}height[i]$。

    • 等等

---

后缀自动机($SAM$)

后缀自动机$(suffixautomaton,SAM)$是用于处理单个字符串的子串问题的强力工具

• 定义

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

  换句话说：

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

SAM 最简单、也最重要的性质是，它包含关于字符串$s$的所有子串的信息。

• 举例

在这里展示一些简单的字符串的后缀自动机。用蓝色表示初始状态，用绿色表示终止状态。

• 性质

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

• 应用

  • 检查字符串是否出现

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

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

    对于每个字符串$P$，算法的时间复杂度为$O(|P|)$。此外，这个算法还找到了模式串$P$在文本串中出现的最大前缀长度。

  • 不同子串个数

    给一个字符串$S$，计算不同子串的个数。

    对字符串$S$构造后缀自动机。每个$S$的子串都相当于自动机中的一些路径,因此不同子串的个数等于自动机中以$t_0$为起点的不同路径的条数。考虑到$SAM$为有向无环图，不同路径的条数可以通过动态规划计算。即令$d_v$为从状态$v$开始的路径数量（包括长度为零的路径），则我们有如下递推方程：
    $$d_v=1+\sum _{w:(v,w,c)\in DAWG}{d}_w$$
    即，$d_v$可以表示为所有$v$的转移的末端的和。

    所以不同字串的个数为$d_{t_0}-1$（因为要去掉空子串）。

    总时间复杂度为：$O(|S|)$。

  • 计算所有不同子串的长度

  • 最小循环移位

    给定一个字符串$S$。找出字典序最小的循环移位。

    容易发现字符串$S+S$包含字符串$S$的所有循环移位作为子串。

    所以问题简化为在$S+S$对应的后缀自动机上寻找最小的长度为$|S|$的路径，这可以通过平凡的方法做到：我们从初始状态开始，贪心地访问最小的字符即可。

    总的时间复杂度为 $O(|S|)$。

---

广义后缀自动机

后缀自动机$(suffixautomaton,SAM)$是用于处理单个字符串的子串问题的强力工具

而广义后缀自动机$(GeneralSuffixAutomaton)$则是将后缀自动机整合到字典树中来解决对于多个字符串的子串问题。

• 常见的为广义后缀自动机：通过用特殊符号将多个串直接连接后，再建立$SAM$。（实现方式简单，而且在面对题目时通常可以达到和广义后缀自动机一样的正确性，但其时间复杂度较为危险。）
• 应用
  • 所有字符中的不同字串个数。
  • 多个字符串间的最长公共子串。

后缀树

• 定义

后缀树，就是包含一则字符串所有后缀的压缩$Trie$。

• 构建过程
  • 根据文本$Text$生成所有后缀的集合。
  • 将每个后缀作为一个单独的关键词，构建一颗压缩字典树${}^{[7]}$（$CompressedTrie$）。

参考文献：$[7]$ https://www.cnblogs.com/gaochundong/p/suffix_tree.html

---

$Manacher$

• 题目描述

给定一个长度为$n$的字符串$s$，找出所有对$(i,j)$使得子串$s[i...j]$为一个回文串。

• 解决思路

  • 首先定义两个数组$d_1[i]，d_2[i]$分别表示以位置$i$为中心的长度为奇数和长度为偶数的回文串个数。换个角度来讲，二者也表示了以位置$i$为中心的最长回文串的半径长度（半径长度$d_1[i]，d_2[i]$均为从位置$i$到回文串最右端位置包含的字符个数）。

    举例：

    • 对于字符串$s=abababc$，以$s[3]=b$为中心有三个奇数长度的回文串，最长回文串半径为$3$，也即$d_1[3]=3$：

      

    • 对于字符串$s=cbaabd$，以$s[3]=a$为中心有两个偶数长度的回文串，最长回文串半径为$2$，也即$d_2[3]=2$：

      

  • 之后，关键就是如何求这两个数组。$Manacher$算法可以用线性的时间复杂度$(O(n))$以及很小的空间复杂度求出。

• $Manache{r}^{[8]}$

算法参考文献中算法部分写的很清晰，很详细，参考文献：$[8]$ https://oi-wiki.org/string/manacher/

• 复杂度$(O(n))$

• 算法实现${}^{[8]}$

  • 计算$d_1[]$

    vector<int> d1(n);
    for (int i = 0, l = 0, r = -1; i < n; i++) {
      int k = (i > r) ? 1 : min(d1[l + r - i], r - i);
      while (0 <= i - k && i + k < n && s[i - k] == s[i + k]) {
        k++;
      }
      d1[i] = k--;
      if (i + k > r) {
        l = i - k;
        r = i + k;
      }
    }
    

  • 计算$d_2[]$

    vector<int> d2(n);
    for (int i = 0, l = 0, r = -1; i < n; i++) {
      int k = (i > r) ? 0 : min(d2[l + r - i + 1], r - i + 1);
      while (0 <= i - k - 1 && i + k < n && s[i - k - 1] == s[i + k]) {
        k++;
      }
      d2[i] = k--;
      if (i + k > r) {
        l = i - k - 1;
        r = i + k;
      }
    }
    

  • 也可以将$d_1[]，d_2[]$的计算统一为的一个$d_1[]$计算

    给定一个长度为$n$的字符串$s$，我们在其$n+1$个空中插入分隔符$\#$，从而构造一个长度为$2n+1$的字符串$s^{\prime }$。举例来说，对于字符串$s=abababc$，其对应的$s^{\prime }=\#a\#b\#a\#b\#a\#b\#c\#$,对$s^{\prime }$计算$d_1[]$。

    容易证明${}^{[8]}$（见参考文献$[8]$）：在$s^{\prime }$中，$d_1[i]$表示在$s$中以对应位置为中心的极大子回文串的总长度加一。

---

回文树$(PalindromicTree)$

• 定义

回文树（也被称为回文自动机）是一种可以存储一个串中所有回文子串的高效数据结构。

• 结构

回文树大概长这样：

回文树也是由转移边和后缀链接（$fail$指针）组成。其中，一个节点的$fail$指针（图中的虚线）指向的是这个节点所代表的回文串的最长回文后缀所对应的节点，但是转移边（图中的实线）并非代表在原节点代表的回文串后加一个字符，而是表示在原节点代表的回文串前后各加一个相同的字符（不难理解，因为要保证存的是回文串）。

因为回文串长度分为奇数和偶数，因此最方便的是建两棵树，一棵树中的节点对应的回文子串长度均为奇数，另一棵树中的节点对应的回文子串长度均为偶数。

• 应用

  • 求本质不同回文子串个数：一个串的本质不同回文子串个数等于回文树的状态数（排除奇根和偶根两个状态）。

  • 求回文子串出现次数：由于回文树的构造过程中，节点本身就是按照 拓扑序${}^{(1)}$插入，因此只需要逆序枚举所有状态，将当前状态的出现次数加到其 fail 指针对应状态的出现次数上即可。

    注：（1）拓扑排序：对一个有向无环图$(DirectedAcyclicGraph$简称$DAG)G$进行拓扑排序，是将$G$中所有顶点排成一个线性序列，使得图中任意一对顶点$u$和$v$，若边$<u,v>\in E(G)$，则$u$在线性序列中出现在$v$之前。通常，这样的线性序列称为满足拓扑次序$(TopologicalOrder)$的序列，简称拓扑序列。实质就是将有向图的顶点排成一个线性序列

  • 最小回文划分

---

序列自动机

序列自动机是接受且仅接受一个字符串的子序列的自动机。

---

最小表示法

最小表示法是用于解决字符串最小表示问题的方法。

• 循环同构

  当字符串$S$可以选定一个位置$i$满足：
  $$S[i...n]+S[1...i-1]=T$$
  则称$S$与$T$循环同构。

• 最小表示

  字符串$S$的最小表示为与$S$循环同构的所有字符串中字典序最小的字符串。

• 算法流程

  • 初始化指着$i$为$0$，$j$为$1$；初始化匹配长度$k$为$0$。
  • 比较第$k$位的大小，根据比较结果跳转相应指针，若跳转后两个指针相同，则随意选一个加一以保证比较的连个字符串不同。
  • 重复上述过程，直到比较结束。
  • 答案为$i$，$j$中较小的一个。

• 代码

int k = 0, i = 0, j = 1;
while (k < n && i < n && j < n) {
  if (sec[(i + k) % n] == sec[(j + k) % n]) {
    k++;
  } else {
    sec[(i + k) % n] > sec[(j + k) % n] ? i = i + k + 1 : j = j + k + 1;
    if (i == j) i++;
    k = 0;
  }
}
i = min(i, j);

---

$Lyndon$分解

• 定义

$Lyndon$串：对于字符串$s$，如果$s$的字典序严格小于$s$的所有后缀的字典序，我们称$s$是简单串，或者Lyndon串。

$Lyndon$分解：串$s$的$Lyndon$分解记为$s=w_1{w}_2\cdots w_k$，其中所有的$w_i$为简单串，并且他们的字典序按照非严格单减排序，即$w_1\ge w_2\ge \cdots \ge w_k$。可以发现，这样的分解存在且唯一。

• $Duval$算法

$Duval$算法可以在$O(n)$的时间内求出一个串的$Lyndon$分解。