java 实现后缀数组及最长回文子串问题
摘要： 后缀数组的java实现。 利用后缀数组来求解最长回文子串问题。
关键词： 后缀数组， 倍增算法， 基数排序，height[]数组，最长回文子串
参考文献：《后缀数组_处理字符串的有效工具》。
part I . 后缀数组中一些相关定义
Suffix(i)表示以i开始的后缀， 对于字符串"aabaaaab"来说，Suffix(2)=baaaab
Rank[i] 表示以Suffix(i) 在所有的后缀 的rank.
Sa[i] 表示排名第i的后缀的下标。
参照图1，很容易理解Rank[] 和Sa[]。
Rank[] 与 Sa[] 有简单的置换关系：
Rank[S[i]] = i;
S[Rank[i]] = i;
求出一个来可以很容易的获得另外一个。
接下来的问题，怎么样求出后缀数组？罗大牛在论文中提到两种算法倍增算法和DC3算法。
倍增算法的思路如下：
第 i 次 倍增时，对以 j 开始的长度为2^i的子串进行排序。利用第 i -1 次 倍增后的结果。
长度为2^i的子串可以表示成2个长度为2^(i-1)的子串的rank，即有两个关键字。然后进行基数排序。
如下图所示，可以很简单的理解。有时候图片比文字的表达能力强大很多。
罗大牛的c语言模板写的相当简洁，不过对于一个java程序员来说，搞清楚那四个数组的含义，还有其中用到的运算技巧真是很痛苦。等哪天心情好了，再看。
一副图片其实就把后缀数组的含义解释的很清楚了。
算法复杂度： 总共需要O(logn)次倍增，每一次倍增进行基数排序需要两次分配和收集，复杂度O(2*n), 总复杂度O(nlogn).
part II . height[]数组
height[]数组的含义：height[i]表示排序为 i 的后缀与排序为 i-1 的后缀的最长公共前缀的长度。
还是看图：
假设rank[i] < rank[j], 任意两个后缀 i 和 j 的最长公共前缀的长度， 是height[rank[i]+1], height[rank[i]+2]...height[rank[j]]的最小值。
如图4所示，suffix(4)=aaab 与 suffix(1)=abaaaab的最长公共前缀的长度为1。
怎么计算height[]数组。
最简单的想法是，计算排序相邻的两个后缀的公共前缀。
for(int i = 1;i<n;i++){
int j = sa[i];
int k = sa[i-1];
height[i] = 0;
while(str[j+height[i]]==str[k+height[i]]) height[i]++;
}
上面几行代码看做伪代码吧，没有考虑太多细节。 最坏的情况：str="aaaaaaaa", suffix(sa[0]) =" a", suffix(sa[1]) ="aa", suffix(sa[2])="aaa",suffix(sa[3])="aaaa" .....
这样最多需要1+2+3+...+n-1次比较，O(n^2)的算法。
怎么样去优化? 可以利用某些性质，使得height[i] 不是每次都从0开始。
对于图4中的例子，suffix(4) ="aaab" , suffix(5)="aab", sa[1] = 4, rank[4] = 1 , sa[2] =5, rank[5] =2 , suffix(4)在suffix(5)的前面，height[rank[5]] =height[2] = 2, 那么suffix(4)和suffix(5)各自向后移动一个，变成aab=suffix(5)和ab=suffix(6)，那么aab也在ab的前面， 因此，对于ab来说，其height[rank[6]]的长度至少为height[rank[5]]-1=1. 仔细观察图4，suffix(sa[2])=aab，suffix(sa[4])=ab，此外，
suffix(sa[3]) = aabaaaab. 因此在计算ab的height时，在与suffix(sa(rank[6]-1))进行比较时，不需要再从0开始进行匹配。
令h[i] 表示height[rank[i]]，则h[i-1]=height[rank[i-1]]
h[]数组的重要性质：h[i]>=h[i-1]-1
part III . 最长回文子串
计算最长回文子串，怎么利用后缀数组解决？
最长回文子串可以转换成求两个后缀的最长公共前缀。
令S="aabaaaab", 构造SS'="aabaaab$baaabaa",其长度为len ,那么求以S中以i为中心的最长回文子串，根据回文串的性质，就变成在SS'中求suffix(i)和suffix(len-i)的最长公共前缀的问题。
另外需要做一些长度为奇数偶数的处理。主要思路是关键。
源码分析如下：
public interface Buckable{
/**第i次基数排序时映射到哪个桶里*/
public int map(int pass);
}
import java.util.Arrays;
public class Bucket {
/**桶，只用来进行计数*/
private int[] buckets;
/**桶的个数，最多需要多少个*/
private int bucketNum;
/**总共需要多少次排序，也就是基数排序时，多关键字的位数*/
private int passes;
public Bucket(int m,int n){
this.bucketNum = m;
this.buckets = new int[m];
this.passes = n;
}
public int[] sort(Buckable[]data){
/**order表示data的进入桶的顺序*/
int[] order = new int[data.length];
for(int i = 0;i<order.length;i++){
order[i] = i;
}
return sort(data,order);
}
/**
*order表示data的进入桶的顺序, 排序完需要重新设置order，
*设置data在下一轮进入桶时的顺序。
*/
public int[] sort(Buckable[]data,int[] order){
for(int i = 0;i<this.passes;i++){
sort(data,order,i);
}
/** data的rank值，从1开始，data相同的话，其rank也相同*/
int[] rank = new int[data.length];
rank[order[0]] = 1;
for(int i = 1;i<order.length;i++){
if(data[order[i]].equals(data[order[i-1]])){
rank[order[i]] = rank[order[i-1]];
}else{
rank[order[i]] = rank[order[i-1]]+1;
}
}
return rank;
}
public void sort(Buckable[] data,int[] order,int pass){
if(data.length!=order.length || pass<0){
throw new IllegalArgumentException();
}
//map the data to the bucket no.
int[] bucketNo = new int[data.length];
for(int i = 0;i<data.length;i++){
bucketNo[i] = data[i].map(pass);
}
Arrays.fill(this.buckets, 0);
//put into bucket
for(int i = 0;i<order.length;i++){
int or = order[i];
int bu = bucketNo[or];
this.buckets[bu]++;
}
for(int i = 1;i<this.bucketNum;i++){
this.buckets[i] += this.buckets[i-1];
}
/**新的order的计算要从后面开始计算，因为一个桶中，进入桶中比较晚的元素，其order也比较大*/
int[] newOrder = new int[order.length];
for(int i = order.length-1;i>=0;i--){
newOrder[this.buckets[bucketNo[order[i]]]-1] = order[i];
this.buckets[bucketNo[order[i]]]--;
}
for(int i = 0;i<order.length;i++){
order[i] = newOrder[i];
}
}
}
/**倍增算法中每个元素的键值，由两个数组成*/
public class DAPair implements Buckable{
private int rank[]= new int[2];
public DAPair(int r0,int r1){
this.rank[0] = r0;
this.rank[1] = r1;
}
@Override
public int map(int pass) {
if(pass>=2 || pass <0){
throw new IllegalArgumentException();
}
if(pass==0){
return this.rank[1];
}
return this.rank[0];
}
@Override
public boolean equals(Object o){
if(o instanceof DAPair){
return this.rank[0] == ((DAPair)o).rank[0] &&
this.rank[1] == ((DAPair)o).rank[1];
}
return false;
}
}
public class SuffixArray {
private String string;
//记录下表为i的后缀的排序
private int rank[];
//记录排序为i的后缀的下标
private int sa[];
private int height[];
public SuffixArray(String string){
if(string==null) throw new NullPointerException();
this.string = string;
this.rank = new int[string.length()];
this.sa = new int[string.length()];
this.height = new int[string.length()];
build();
}
private DAPair[] fromArray(int[] a,int inc){
DAPair[] pairs = new DAPair[a.length];
for(int i = 0;i+inc<a.length;i++){
pairs[i] = new DAPair(a[i],a[i+inc]);
}
for(int i = a.length-inc;i<a.length;i++){
pairs[i] = new DAPair(a[i],0);
}
return pairs;
}
private void build(){
if(this.string.isEmpty()==false){
//build suffix array
int len = string.length();
class LowcaseCharacter implements Buckable{
private char ch;
public LowcaseCharacter(char c){
this.ch = c;
}
@Override
public int map(int pass) {
if(pass!=0) throw new IllegalArgumentException();
return ch;
}
@Override
public boolean equals(Object o){
if(o instanceof LowcaseCharacter){
return ((LowcaseCharacter) o).ch==this.ch;
}
return false;
}
}
Buckable[] buckables = new Buckable[len];
for(int i=0;i<len;i++){
buckables[i] = new LowcaseCharacter(string.charAt(i));
}
Bucket bucket = new Bucket(130,1);
this.rank = bucket.sort(buckables);
bucket = new Bucket(this.string.length()+2,2);
//倍增算法
for(int i = 1;i<len;i=i<<1){
DAPair[] dapairs = fromArray(this.rank,i);
for(int j = 0;j<this.sa.length;j++){
this.sa[j] = j;
}
this.rank = bucket.sort(dapairs,this.sa);
}
for(int i = 0;i<this.rank.length;i++){
this.rank[i]--;
}
//build height array
int k = 0;
for(int i=0;i<this.sa.length;i++){
if(k>0) k--;
if(rank[i]==0) continue;
int j = this.sa[rank[i]-1];
for(;i+k<this.string.length() &&
j+k<this.string.length() &&
this.string.charAt(i+k)==this.string.charAt(j+k);
k++);
height[rank[i]] = k;
}
}
}
//Suffix(id1)和Suffix(id2)的最长公共前缀的长度
public int getLCP(int id1,int id2){
if(id1==id2) return this.string.length()-id1+1;
int r1 = this.rank[id1];
int r2 = this.rank[id2];
int minr = r1<r2?r1:r2;
int maxr = r1>r2?r1:r2;
int lcp = this.string.length();
for(int i = minr+1;i<=maxr;i++){
if(lcp>this.height[i]){
lcp = this.height[i];
}
}
return lcp;
}
public int[] getRank(){
return this.rank;
}
public int[] getSuffixArray(){
return this.sa;
}
//最长回文子串
public String getLP(){
StringBuffer buffer = new StringBuffer(this.string.length()*2+2);
for(int i = 0;i<this.string.length();i++){
buffer.append("#"+this.string.charAt(i));
}
buffer.append("#$");
for(int i = this.string.length()-1;i>=0;i--){
buffer.append("#"+this.string.charAt(i));
}
buffer.append("#");
String newStr = buffer.toString();
SuffixArray sa = new SuffixArray(newStr);
int maxLcp = -1;
int id = -1;
for(int i = 1;i<newStr.length()/2;i++){
int lcp = sa.getLCP(i, newStr.length()-i-1);
if(maxLcp<lcp) {
maxLcp = lcp;
id = i;
}
}
String rs = newStr.substring(id-maxLcp+1,id+maxLcp);
rs = rs.replaceAll("#", "");
return rs;
}
public static void main(String[]args){
String s = "ababababa";
SuffixArray sa = new SuffixArray(s);
System.out.println(sa.getLP());
}
}