回文字符串问题

回文字符串问题

一、动态规划法

定义boolean型的 p[i][j]，为 Si 到 Sj 是否为回文，true 说明 Si 到 Sj 是回文字符串
则有，P[i,j] = (P[i + 1, j - 1] && Si ==Sj)
初始条件p[i, i] = true, p[i,i+1] = S_i==S_i+1
动态规划的思想是首先判断相邻的字符串是否是回文，然后继续判断连续的三个字符是否是回文，然后是四个，…，直到判断完整个字符串
时间复杂度O(n²)，空间复杂度O(n²)
代码实现：

1. publicstaticString longestPalindromeDP(String str){
2. if(str ==null|| str.length()<=0)returnnull;
4. int len = str.length();
5. int startIndex =0;
6. int maxLen =1;
8. boolean[][] p =newboolean[len][len];
9. for(int i =0; i < len; i++){
10. for(int j =0; j < len; j++){
11. if(i == j){
12. p[i][j]=true;
13. continue;
14. }
15. p[i][j]=false;
16. }
17. }
18. for(int i =0; i < len -1; i++){
19. //相邻的相同
20. if(str.charAt(i)== str.charAt(i+1)){
21. p[i][i+1]=true;
22. startIndex = i;
23. maxLen =2;
24. }
25. }
27. for(int i =3; i <= len; i++){
28. for(int j =0; j < len - i +1; j++){
29. //当前判断回文长度为i，起始位置为j
30. int currLast = j + i -1;
31. if(str.charAt(j)== str.charAt(currLast)&& p[j+1][currLast-1]){
32. p[j][currLast]=true;
33. startIndex = j;
34. maxLen = i;
35. }
36. }
37. }
39. return str.substring(startIndex, startIndex+maxLen);
40. }

二、中心检测法

回文字符串的特点是以中心对称，从0开始依次遍历字符串，每次以选取的点为中心，向两边检测，判断是否符合回文字符串。
时间复杂度O(n²)，空间复杂度O(1)

1. publicstaticString longestPalindromeCerter(String str){
2. if(str ==null|| str.length()<=0)returnnull;
3. String longest = str.substring(0,1);
4. for(int i =0; i < str.length()-1; i++){
5. //获得以i为中心的回文字符串
6. String s = getPalindromeCerter(str, i, i);
8. if(s.length()> longest.length()){
9. longest = s;
10. }
12. //获得以i和i+1为中心的回文字符串
13. s = getPalindromeCerter(str, i, i +1);
15. if(s.length()> longest.length()){
16. longest = s;
17. }
18. }
19. return longest;
20. }
22. //获得以i,j为中心的回文字符串i==j时，就是以i为中心的回文字符串
23. privatestaticString getPalindromeCerter(String str,int i,int j){
24. while(i >=0&& j < str.length()&& str.charAt(i)== str.charAt(j)){
25. i --;
26. j ++;
27. }
28. return str.substring(i +1, j);
29. }

三、添加辅助标志

首先我们把字符串S改造一下变成T，改造方法是：在S的每个字符之间和S首尾都插入一个”#”。这样做的理由你很快就会知道。

例如，S=”abaaba”，那么T=”#a#b#a#a#b#a#”。

想一下，你必须在以Ti为中心左右扩展才能确定以Ti为中心的回文长度d到底是多少。（就是说这一步是无法避免的）
为了改进最坏的情况，我们把各个Ti处的回文半径存储到数组P，用P[i]表示以Ti为中心的回文长度。那么当我们求出所有的P[i]，取其中最大值就能找到最长回文子串了。

对于上文的示例，我们先直接写出所有的P研究一下。
i = 0 1 2 3 4 5 6 7 8 9 A B C
T = # a # b # a # a # b # a #
P = 0 1 0 3 0 1 6 1 0 3 0 1 0

显然最长子串就是以P[6]为中心的”abaaba”。

你是否发现了，在插入”#”后，长度为奇数和偶数的回文都可以优雅地处理了？这就是其用处。

现在，想象你在”abaaba”中心画一道竖线，你是否注意到数组P围绕此竖线是中心对称的？再试试”aba”的中心，P围绕此中心也是对称的。这当然不是巧合，而是在某个条件下的必然规律。我们将利用此规律减少对数组P中某些元素的重复计算。

我们来看一个重叠得更典型的例子，即S=”babcbabcbaccba”。

上图展示了把S转换为T的样子。假设你已经算出了一部分P。竖实线表示回文”abcbabcba”的中心C，两个虚实线表示其左右边界L和R。你下一步要计算P[i]，i围绕C的对称点是i’。有办法高效地计算P[i]吗？

我们先看一下i围绕C的对称点i’（此时i’=9）。

据上图所示，很明显P[i]=P[i’]=1。这是因为i和i’围绕C对称。同理，P[12]=P[10]=0，P[14]=P[8]=0。

现在再看i=15处。此时P[15]=P[7]=7？错了，你逐个字符检测一下会发现此时P[15]应该是5。

为什么此时规则变了？

如上图所示，两条绿色实线划定的范围必定是对称的，两条绿色虚线划定的范围必定也是对称的。此时请注意P[i’]=7，超过了左边界L。超出的部分就不对称了。此时我们只知道P[i]>=5，至于P[i]还能否扩展，只有通过逐个字符检测才能判定了。

在此例中，P[21]≠P[9]，所以P[i]=P[15]=5。

我们总结一下上述分析过程，就是这个算法的关键部分了。
if P[ i’ ] < R – i,
then P[ i ] ← P[ i’ ]
else P[ i ] ≥ R - i. (此时要穿过R逐个字符判定P[i]).

很明显C的位置也是需要移动的，这个很容易：
如果i处的回文超过了R，那么就C=i，同时相应改变L和R即可。

每次求P[i]，都有两种可能。如果P[i‘] < R – i，我们就P[i] = P[i’]。否则，就从R开始逐个字符求P[i]，并更新C及其R。此时扩展R（逐个字符求P[i]）最多用N步，而求每个C也总共需要N步。所以时间复杂度是2*N，即O(N)。
时间复杂度O(n)，空间复杂度O(n)

实现：

1. /**
2. * 通过添加辅助标识，来获得最长回文子串
3. * @param str
4. * @return
5. */
6. publicstaticString longestPalindromeAddTag(String str){
7. if(str ==null|| str.length()<=0)returnnull;
8. StringBuilder sb = addTag(str);
9. int[] p =newint[sb.length()];//以i为中心的，左右半边的回文子串长度（包括#）
10. p[0]= p[sb.length()-1]=0;
11. int center =0;int r =0;
12. for(int i =1; i < sb.length()-1; i++){
13. int i_mirror = center -( i - center);
14. int diff = r - i;
15. if(i_mirror>=0){
16. if(p[i_mirror]< diff) p[i]= p[i_mirror];
17. else{
18. center = i;
19. p[i]= diff;
20. int pre = i - p[i]-1;//往前
21. int after = i + p[i]+1;//往后
22. while(pre >=0&& after < sb.length()&&
23. sb.charAt(pre)== sb.charAt(after)){
24. p[i]++;
25. pre --;//往前
26. after ++;//往后
27. }
28. r = i + p[i];//当前中心的右边缘
29. }
30. }else{
31. center = i;
32. p[i]=0;
33. int pre = i - p[i]-1;//往前
34. int after = i + p[i]+1;//往后
35. while(pre >=0&& after < sb.length()&&
36. sb.charAt(pre)== sb.charAt(after)){
37. p[i]++;
38. pre --;//往前
39. after ++;//往后
40. }
41. r = i + p[i];//当前中心的右边缘
42. }
43. }
45. int maxLen =0;
46. int index =0;
47. for(int i =0; i < sb.length(); i++){
48. if(p[i]> maxLen){
49. maxLen = p[i];
50. index = i;
51. }
52. }
53. int start =(index >>1)-(maxLen >>1);
54. intlast=(index >>1)+(maxLen >>1);
55. if((index &0x01)==1)last++;
56. return str.substring(start,last);
57. }
59. /**
60. * 向字符串中插入#，如 ab，则返回 #a#b#
61. * @param str
62. * @return
63. */
64. privatestaticStringBuilder addTag(String str){
65. StringBuilder sb =newStringBuilder();
66. sb.append('#');
67. for(int i =0; i < str.length(); i++){
68. sb.append(str.charAt(i));
69. sb.append('#');
70. }
71. return sb;
72. }

四、字符串变成回文字符串需要添加的字符数

1. f(i,j)表示s[i..j]变为回文串需要添加的最少字符数。
2. f(i,j)=0if i>=j
3. f(i,j)=f(i+1,j-1)if i<j and s[i]==s[j]
4. f(i,j)=min(f(i,j-1),f(i+1,j))+1if i<j and s[i]!=s[j]

实现：

1. /**
2. * 添加多少字符串使字符串变为回文串
3. * @param str
4. * @return
5. */
6. publicstaticint addTobePalindrome(String str){
7. if(str ==null|| str.length()<=0)return0;
9. int len = str.length();
11. int[][] p =newint[len][len];
12. for(int i =0; i < len; i++){
13. for(int j =0; j < len; j++){
14. p[i][j]=0;
15. }
16. }
18. for(int i =2; i <= len; i++){
19. for(int j =0; j < len - i +1; j++){
20. int currLast = j + i -1;
21. if(str.charAt(j)== str.charAt(currLast)){//判断s[i...j]需要添加的字符个数
22. p[j][currLast]= p[j+1][currLast-1];
23. }else{
24. p[j][currLast]=1+(p[j][currLast -1]< p[j+1][currLast]? p[j][currLast -1]: p[j+1][currLast]);
25. }
26. }
27. }
29. return p[0][len-1];
30. }

---

参考：
[1]http://www.cnblogs.com/bitzhuwei/p/Longest-Palindromic-Substring-Par-I.html
[2]http://www.cnblogs.com/bitzhuwei/p/Longest-Palindromic-Substring-Part-II.html

来自为知笔记(Wiz)