后缀数组是处理字符串的有力工具

后缀数组是处理字符串的有力工具。后缀数组是后缀树的一个非常精巧的替代品，它比后缀树容易编程实现，能够实现后缀树的很多功能而时间复杂度也并不逊色，而且它比后缀树所占用的内存空间小很多。

子串：字符串S的子串r[i..j]，i<=j，表示r串中从i到j这一段，也就是顺次排列r[i],r[i+1],...,r[j]形成的字符串。

后缀：后缀是指从某个位置i开始到整个串末尾结束的一个特殊子串。字符串 s 的从第i个字符开始的后缀表示为Suffix(i)， 也就是Suffix(i)=r[i..len(s)]。

大小比较：关于字符串的大小比较，是指通常所说的“字典顺序”比较，也就是对于两个字符串u、v，令i 从1 开始顺次比较u[i]和v[i]，如果u[i]=v[i]则令i加1，否则若u[i]<v[i]则认为u<v，u[i]>v[i]则认为u>v（也就是v<u），比较结束。如果 i>len(u)或者i>len(v)仍比较不出结果，那么，若len(u)<len(v)则认为u<v，若len(u)=len(v)则认为u=v，若len(u)>len(v)则u>v。
从字符串的大小比较的定义来看，S的两个开头位置不同的后缀u和v进行比较的结果不可能是相等，因为u=v的必要条件len(u)=len(v)在这里不可能满足。

后缀数组：后缀数组SA是一个一维数组，它保存1..n的某个排列SA[1]，SA[2]，……，SA[n]，并且保证Suffix(SA[i])<Suffix(SA[i+1])，1<=i<n。也就是将S的n个后缀从小到大进行排序之后把排好序的后缀的开头位置顺次放入SA中。

1 后缀数组求最长公共子串（LCS）

解法：将两个字符串用一个特殊符号（两个字符串中都没有，比如‘#’）连接起来，构造连接后字符串的后缀数组，求后缀数组中的最长公共前缀，要保证最长的公共前缀在原来两个字符串中都出现，而不是只出现在一个字符串中，这就是特殊连接符号的作用。

[cpp]  view plain copy

1. #include <iostream>  
2. using namespace std;  
3.   
4. //用于qsort的比较函数  
5. int pstrcmp(const void *p, const void *q)   
6. {       
7.     return strcmp(*(char**)p,*(char**)q);   
8. }  
9.   
10. //最长公共前缀  
11. int comlen_suff(char * p, char * q)   
12. {      
13.     int len = 0;  
14.     int count = 0; //保证两个子串中只有一个含有‘#’，LCS才来自两个字符串，否则可能来自同一个字符串  
15.     while(*p && *q && *p++ == *q++)       
16.     {           
17.         ++len;           
18.         if(*p == '#' || *q == '#')  
19.         {  
20.             break;  
21.         }  
22.     }  
23.     while(*p)  
24.     {  
25.         if(*p++ == '#')  
26.         {  
27.             ++ count;  
28.             break;  
29.         }  
30.     }  
31.     while(*q)  
32.     {  
33.         if(*q++ == '#')  
34.         {  
35.             ++ count;  
36.             break;  
37.         }  
38.     }  
39.     if(count == 1)  
40.         return len;  
41.     return 0;   
42. }     
43.   
44. //最长公共子串  
45. int LCS(char * X, char * Y)   
46. {  
47.     char * suff[999];  
48.     int maxlen = 0;  
49.     int suf_index;  
50.     int xlen = strlen(X);  
51.     int ylen = strlen(Y);  
52.     int len_suff = xlen + ylen + 1;       
53.     char * arr = new char[len_suff + 1];  // 将X和Y连接到一起  
54.     strcpy(arr,X);     
55.     arr[xlen] = '#';  
56.     strcpy(arr + xlen + 1, Y);         
57.     for(int i = 0; i < len_suff; ++i)  // 初始化后缀数组  
58.     {  
59.         suff[i] = &arr[i];       
60.     }  
61.     qsort(suff, len_suff, sizeof(char *), pstrcmp);      
62.     for(int i = 0; i < len_suff-1; ++i)      
63.     {  
64.         int len = comlen_suff(suff[i],suff[i+1]);  
65.         if(len > maxlen)          
66.         {  
67.             maxlen = len;         
68.             suf_index = i;     
69.         }  
70.     }  
71.     printf("%.*s\n", maxlen, suff[suf_index]);  
72.     delete[] arr;  
73.     return maxlen;  
74. }  
75.   
76. int main()  
77. {  
78.     cout<<LCS("aabaaba","aba")<<endl;  
79.     return 0;  
80. }  

2 后缀数组求最长回文子串（LPS）

解法：将字符串的逆序与原来字符串用特殊符号连接，构造后缀数组，求后缀数组中的最长公共前缀，保证最长公共前缀出现在特殊连接符号的两端。

[cpp]  view plain copy

1. #include <iostream>  
2. using namespace std;  
3.   
4. //用于qsort的比较函数  
5. int pstrcmp(const void *p, const void *q)   
6. {       
7.     return strcmp(*(char**)p,*(char**)q);   
8. }  
9.   
10. //最长公共前缀  
11. int comlen_suff(char * p, char * q)   
12. {      
13.     int len = 0;  
14.     int count = 0; //保证两个子串中只有一个含有‘#’，LCS才来自两个字符串，否则可能来自同一个字符串  
15.     while(*p && *q && *p++ == *q++)       
16.     {           
17.         ++len;           
18.         if(*p == '#' || *q == '#')  
19.         {  
20.             break;  
21.         }  
22.     }  
23.     while(*p)  
24.     {  
25.         if(*p++ == '#')  
26.         {  
27.             ++ count;  
28.             break;  
29.         }  
30.     }  
31.     while(*q)  
32.     {  
33.         if(*q++ == '#')  
34.         {  
35.             ++ count;  
36.             break;  
37.         }  
38.     }  
39.     if(count == 1)  
40.         return len;  
41.     return 0;   
42. }  
43.   
44. //最长回文子串  
45. int LPS(char * X)   
46. {  
47.     char * suff[999];  
48.     int maxlen = 0;  
49.     int suf_index;  
50.     int xlen = strlen(X);  
51.     int len_suff = 2 * xlen + 1;      
52.     char * arr = new char[len_suff + 1];  // 将X和逆序X连接到一起    
53.     strcpy(arr,X);  
54.     arr[xlen] = '#';  
55.     char *p = X;  
56.     char *q = arr + len_suff;    
57.     *q = '\0';  
58.     while(*p && (*--q = *p++)); // 逆序复制  
59.     for(int i = 0; i < len_suff; ++i)  // 初始化后缀数组  
60.     {  
61.         suff[i] = &arr[i];     
62.     }  
63.     qsort(suff, len_suff, sizeof(char *), pstrcmp);     
64.     for(int i = 0; i < len_suff-1; ++i)      
65.     {          
66.         int len = comlen_suff(suff[i],suff[i+1]);      
67.         if(len > maxlen)  
68.         {            
69.             maxlen = len;  
70.             suf_index = i;  
71.         }    
72.     }  
73.     printf("%.*s\n", maxlen, suff[suf_index]);  
74.     delete[] arr;  
75.     return maxlen;  
76. }  
77.   
78. int main()  
79. {  
80.     cout<<LPS("aabaab")<<endl;  
81.     return 0;  
82. }  

3 后缀数组求最长重复子串（LRS）

解法：构造字符串的后缀数组，对后缀数组排序，再两两比较得到最长的重复子串

[cpp]  view plain copy

1. //compare funciton used by qsort()  
2. int pstrcmp(const void *p, const void *q)  
3. {  
4.     return strcmp(*(char **)p, *(char **)q);  
5. }  
6.   
7. //get max common length of string p and q  
8. int comlen(char *p, char *q)  
9. {  
10.     int len = 0;  
11.     while (*p && (*p++ == *q++))  
12.         len++;  
13.     return len;  
14. }  
15.   
16. //get max repeat substring of str   
17. int find_max_repeat(char* str, char* result, int & len)  
18. {  
19.     int temlen, maxi, maxlen = -1;  
20.     char *a[99999];  
21.     int n = 0;  
22.   
23.     while (*str != '\0')  
24.     {  
25.         a[n++] = str++;  
26.     }  
27.     qsort(a, n, sizeof(char *), pstrcmp);  
28.     for (int i = 0; i < n-1; i++)  
29.     {  
30.         temlen = comlen(a[i], a[i+1]);  
31.         if (temlen > maxlen)  
32.         {  
33.             maxlen = temlen;  
34.             maxi = i;  
35.         }  
36.     }  
37.     result = a[maxi];  
38.     len = maxlen;  
39.     printf("%.*s\n", maxlen, result);  
40.     return maxlen;  
41. }  

4 后缀数组求最长的没有重复字符的子串

解法：对这个字符串构造后缀数组，在每个后缀数组中，寻找没有重复字符的最长前缀，就是要找的子串。

[cpp]  view plain copy

1. //得到字符串最长的无重复的前缀长度  
2. int longestlen(char * p)  
3. {  
4.     int hash[256];  
5.     int len = 0;  
6.     memset(hash,0,sizeof(hash));  
7.     while (*p && !hash[*p])  
8.     {  
9.         hash[*p] = 1;  
10.         ++ len;  
11.         ++ p;  
12.     }  
13.     return len;  
14. }  
15.   
16. //使用后缀数组解法  
17. int longest_unique_substring(char * str)  
18. {  
19.     int maxlen = -1;  
20.     int begin = 0;  
21.     char *a[99999];  
22.     int n = 0;  
23.     while(*str != '\0')  
24.     {  
25.         a[n++] = str++;  
26.     }  
27.     for (int i=0; i<n; i++)  
28.     {  
29.         int temlen = longestlen(a[i]);  
30.         if (temlen > maxlen)  
31.         {  
32.             maxlen = temlen;  
33.             begin = i;  
34.         }  
35.     }  
36.     printf("%.*s\n", maxlen, a[begin]);  
37.     return maxlen;  
38. }