后缀数组及其应用

其中l=2^k,且 l>=n
O(n)排序 。。。 。。。
2-rank[]
2-sa[]
8-rank[] 8-sa[] O(n)排序 4-rank[] 4-sa[] O(n)排序
算法最多进行logn次，每次 时间为O(N).所以最终时间 复杂度为O(nlogn)
倍增算法——思想总结
1、定义k-rank[],并利用k-rank[]求出2k-rank[]，高 效的比较；充分利用了后缀之间的联系；
缺点： 该算法实现过于复杂，细节较多，且代码量较长，对于 一名信息竞赛的选手而言，在短短的5个小时内，要完全正 确地写出后缀树谈何容易。在各种各样的比赛中，我们要 选择实现相对简单，且效率较高的算法和数据结构。
随着广大OIERS的呼声，
后缀数组横空出世！！
*后缀数组 （Suffix Arrary）
后缀树的特点： 后缀树实质上是一棵字典树。从根节点到任意叶子节点 都对应了原串的一个后缀。但与Trie结构不同的是树上的每一 条边记录的不是单个字母，而是一个字符串。这样一来，将 空间从Trie的O(N^2)降到O(N) 。 同时，Trie的构造时间是O(N^2),而后缀树的构造时间仅 为O(N)。这也是后缀树广为人知的原因。 下面我们看个实例：
后缀数组的构造方法：
比较直观的想法——暴力排序： 把n个后缀预处理出来，快排，堆排，归并等，时 间复杂度O(nlogn)，看上去还不错。 但仔细想想，两个字符串间比较有个strcmp(),这 明显不是线性。况且kmp也需要O(N+M)的时间，这样 一来时间复杂度接近O(n^2)。 当N>10000时就悲剧了。。。。。
通过上面的例子，通过k-rank[]可以在O(1)的时间内 完成suffix(i)和suffix(j)的比较。这样就充分利用了后缀之 间有机的联系。 具体实现当然不是枚举每两个串进行比较。进一步想 想，这样比较不就是将每个后缀看作一个元素，k-rank[i]作 为第一关键字，k-rank[i+k]作为第二关键字进行排序吗？ 这时，排序方法又是一个大问题。虽然快排等比较型排序 可以做到O(nlogn)，但是还不能满足后缀树组的高效要求。 每个元素只有两个关键字，而且关键字分布比较集中，相信聪 明的你已经想到了：
后缀数组及 其应用
本文探讨内容：
1、后缀树组的概念及构造方 法； 2、后缀树组的相关应用；
有关后缀树（Suffix Tree ）：
提到后缀数组，我们不由自主地会想到后缀树。后缀树 （Suffix tree）是一种数据结构，能快速解决很多关于字符 串的问题。后缀树的概念最早由Weiner 于1973年提出，既 而由McCreight 在1976年和Ukkonen在1992年和1995年加 以改进完善。
有了这个性质，我们就可以根据h[1],h[2],…..,h[n]顺序先 计算出h[i]。再根据height[i]=h[sa[i]]计算出height[]数组。
在h[i]时，由于suffix(i)与suffix(sa[rank[i]-1])的前 h[i-1]-1个字符已经相同了，所以最多只需要h[i]-h[i-1]+2次 比较就能找到某两个对应字符不相同。所以总的时间复杂度最 多不会超过4n次，算法是线性的， 算法总流程
S=“BANANAS”。
BANANAS 的后缀树
BANANAS 的Trie
后缀树在处理字符串问题上有着得天独厚的空间优势和速 度优势，在最坏情况下, 后缀树的节点数也不会超过2N。主 流的构造方法是由Esko Ukkonen 于1995年发明的一种线 性构造法，理论时间复杂度为O(N)。非常优秀。
O(nlogn)
O(n)。
1、double_algorithm构造后缀数组；。。。。。O(nlogn) 2、线性计算出h[]数组，再逐个推出height[i]；。。。O(n) 3、ST算法对height[]做预处理；。。。。。。。O(nlogn) 4、查询LCP(I,J)只需查询height[i…j]中的最小值 O(1)
在此，我向大家介绍后缀数组的强力外援
——LCP（Longest Common Prefix）
定义： LCP(I,J)={suffix(sa[i])与suffix(sa[j])的最长公共前缀长 度。}即排好序的后缀中第i名和第j名的最长公共前缀。
重要性质：
LCP(I,J)=min{LCP(K,K-1)} I <= K <= J 现在摆在我们面前的问题变成了如何快速地求出LCP(I,J)。 从LCP的性质可以看出，suffix(i)与suffix(j)的最长公共前缀 实际上是排名位于i与j之间 排名相邻的后缀的最长公共前缀 中最短的那个前缀。 RMQ问题！！！ 排名相邻的后缀的最长公共前缀可以预处理出来，那么 查询LCP(I,J)就相当于查询LCP(I+1,I)到LCP(J-1,J)之间的最 小值。
suffix(i) 从上图可以看出：
Suffix(j)
比较suffix(i)和suffix(j)只需先比较红色部分，再比较 绿色部分。而由于k-rank[]是已知的。所以有以下结论：
2k-rank[i] > 2k-rank[j]
k-rank[i] > k-rank[j] 或 k-rank[i] == k-rank[j] && k-rank[i+k] > k-rank[j+k]
接着将筒中的数依次倒出，得到： 81, 22, 73, 93, 43, 14, 55, 65, 28, 39 再按照十位数依次放入筒中. 0 1 14 2 22 28 3 39 4 43 5 55 6 7 8 81 9 93
65 73
按顺序倒出后，得到排好序的序列： 14，22，28，39，43，55，65，73，81，93 基数排序的时间复杂度是时间复杂度可以为O(n)。
O(N)
Height[]数组及其高效计算
还是先看定义：
height[i] = LCP(sa[i-1],sa[i])
即排名相邻的两个后缀的最长公共前缀长度。 对于height[]数组的计算，我们并不能顺序递推。需要充 分利用字符串之间的联系，改变他的计算顺序。 所以，我们定义h[i]:
h[i] = height[rank[i]]
现在只需求出1-rank[]和1-sa[]就可以每次通过O(n)的排 序转移。至于求1-rank[]与1-sa[]，把原串中的字符排序即可， 快排或基数排序都可以，均不影响算法的时间复杂度。但是建 议使用基数排序。 O(n)排序 原始串S 1-rank[],1-sa[] O(n)排序 L-rank[],l-sa[].
2、将k每次加倍，时间压缩成logn级。
3、类似于动规中的ST。
讲了这么多，我们来看个实例：
最长公共子串问题。
最长公共子串问题： 给定两个字符串S1[],S2[]。求出他们的最长公共子串。 例如： s1=“she handsome”,s2=“he slim”。则输出字符 串”he”。(N<=10^5) 首先明确一个事实，任何子串都是某一后缀的前缀。那么， 很直观的想法，把两个串接起来，中间用‘$’隔开。对这个新 的字符串求后缀树组，每次求出排名相邻的两个后缀的最长前 缀即可。当然，这个最长前缀不能跨过‘$’。 新问题出现了： 最长公共前缀怎么求？难道一个一个比较，那么时间复杂 度又回到了O(N^2)级了。看来，如果只有sa[]，后缀数组还 不够强大。
首先给出一些新的定义： 1、字符串均以“000000….”结尾，‘0’为最 小字符； 2、定义k-rank[],即在比较每个后缀前k个字符 的情况下，suffix(i)的名次记做k-rank[i].类似地定义 k-sa[]。
当前求2k-rank[],2k-sa[]。
K个字符 K个字符 K个字符 K个字符
关于RMQ问题(Range Minimum Query)
线段树等高级数据结构维护，O(nlogn)构造，O(logn) 查询，ST算法O(nlogn)构造，O(1)的查询。RMQ标准算法 O(n)构造，0(1)查询。
在信息竞赛中，均衡利弊还是ST实现简单，效率较高， 性价比高。 这样一来，我们可以在O(1)的时间内查询任意两个后缀的 最长公共前缀。这也是后缀数组最强大的功能之一。 貌似问题得到了解决，回顾刚才的过程，我们漏掉了一 个重要的过程——预处理排名相邻后缀 暴力枚举后缀再比较。时间显然超过了O(n)。我们希 望能在O(n)时间内解决这一问题
现在，我们可以很好的解决刚才的最长公共子串问题了， 构造好后缀数组后，答案就是height[i]中的最大值。当然，要 注意判断公共子串不能跨过‘$’。 时间复杂度O(nlogn)。 下面，我们来看另外一个例子：
最长回文子串（ural1297）:
给出一个字符串，请输出其最长回文子串。比如： s=“abzrzbaccc”，输出：abzrzba 跟上题类似，一个直观的想法。
即suffix(i)与排名在它前一位的后缀的最长公共前缀长度。 不难得出h[i]的重要性质：
h[i] >= h[i-1] - 1




证明：h[i]>=h[i-1]-1 证： 首先，明确一个基本事实：对于任意的i<=j<k，有LCP(j,k)>LCP(i,k)。直观上 理解相对于同一个后缀，与他排得越近的后缀的最长公共前缀一定更长。 1、若h[i-1]<=1,则h[i]>=0>=h[i-1]-1显然成立。 2、若h[i-1]>1. 带入定义式，即height[rank[i-1]]>1,又因为height[0]=0,所以rank[i-1]>1。 为了简单起见,令j=i-1,k=sa[rank[i-1]-1]。则suffix(k)<suffix(j)。 因为h[i-1]>1，所以LCP(rank[k+1],rank[i])=h[i-1]-1. 又rank[k+1]<rank[i],所以rank[i]-1>=rank[k+1]. 利用开头那个引理, h[i]=LCP(rank[i]-1,rank[i]) >=LCP(rank[k+1],rank[i])=h[i-1]-1. 综上，有h[i]>=h[i-1]-1。