一、回文串、子串、子序列

" 回文串 ( Palindrome ) " 是 正反都一样的字符串 , abccba , 001100 等字符串 ;

给定一个字符串 " abcd " ,

" 子串 ( SubString ) "是连续取的子字符串 , 如 : “ab” , “bc” , “cd” , “bcd” 等 , 不能跳跃字符 ; ( 连续字符 )

$n$ 个字符串的子串个数是 $\frac{n(n+1)}{2}+1$ 个 ;

" 子序列 ( SubSequence ) " 是可以非连续取字符串中的字符 , 前后顺序不允许颠倒 , 如 “ad” , “bd” , “acd” 等 ; ( 非连续字符 )

$n$ 个字符串的子串个数是 $2^n$ 个 ( 集合的子集数 ) ;

验证一个字符串是否是回文串 , 最坏的情况下需要遍历 $\frac{n}{2}$ 次 ;

因此最暴力的方法验证回文子串 , 就是验证 $\frac{n(n+1)}{2}+1$ 个子字符串是否是回文串 , 每次都要遍历 $\frac{n}{2}$ 次 ;
暴力算法的时间复杂度是 $O(n^3)$ ;

二、最长回文子串

问题链接 : https://www.lintcode.com/problem/200/description

给出一个字符串（假设长度最长为1000），求出它的最长回文子串，你可以假定只有一个满足条件的最长回文串。

1、中心线枚举算法

中心线枚举算法 :

使用暴力算法 , 算法的复杂度是 $O(n^3)$ ;

暴力算法中有 性能浪费的地方 , 找出这个性能浪费的点 , 将其优化 , 就可以得到更好的算法 ;

如果一个字符串是回文子串 , 那么该字符串的 中心的 $3$ 个字符肯定是回文串 , aba 形式的 ;

如 “mabcban” 字符串 , 如果已经检测到了 中间的 bcb 是回文串 , 再次扩大范围时 , 直接检测 “bcb” 两遍的单个字符是否一样即可 , 左右两遍各是一个 a , 一样 ;
完全没有必要再次监测 abcb , bcba 是否是字符串 , 这样就造成了性能上的浪费 ;

按照上述思想 , 可以进行如下设计 :
中轴线 : 回文串的关键在于其 " 中轴线 " , 以中轴线为中心 , 遍历两边的字符串是否相等 ;

如 : “mabcban” 字符串中 , 回文子串是 “abcba” , 字符 c 是中轴线 , 从该中轴线触发 , 两侧的字符串都相等 ;
第一层遍历 : 先对字符串进行一次遍历 , 假设遍历的当前字符是中轴线 ,
第二层遍历 : 再次遍历 , 比较两侧的字符是否相等 , 如果相等 , 则说明是回文子串 , 逐步向外遍历 , 看回文子串的最大长度 ;

该思想是取每个中轴线向两侧尽可能取最长的回文子串 ;

外层遍历设计 :

回文串有两种情况 , 假如字符串有 $n$ 个字符 ;

• 情况一 : “abcba” 奇数个字符组成 , 中心轴是字符 , 有 $n$ 个需要遍历的中心线 ;
• 情况二 : “abba” 偶数个字符组成 , 中心轴是字符之间的间隔 , 有 $n-1$ 个需要遍历的中心线 ;

情况一 很容易实现 , 遍历每个字符即可 , 然后比较字符两端的字符是否相等 , 逐步扩大范围 , 直到获得最长回文子串 ;

情况二 需要 设置两个指针 L 和 R , 分别指向中心轴两侧 , L 指向中心轴左侧 , R 指向中心轴右侧 , 比较指针指向的字符是否相等 , 如果相等 , 然后两个指针各往两边走 , 继续比较指向的字符是否相等 , 直至获取到最长的回文子串 ;

2、中心线枚举算法代码示例

代码示例 :

class Solution {
    /**
     * @param s: 输入字符串
     * @return: 返回最长回文子串
     */
    public String longestPalindrome(String s) {
        if (s == null) {
            return null;
        }

        String longest = "";
        for (int i = 0; i < s.length(); i ++) {
            // 回文子串字符个数是奇数个
            String oddPalindrome = getPalindrome(s, i, i);
            if (longest.length() < oddPalindrome.length()) {
                longest = oddPalindrome;
            }

            // 回文子串字符个数是偶数个
            String evenPalindrome = getPalindrome(s, i, i + 1);
            if (longest.length() < evenPalindrome.length()) {
                longest = evenPalindrome;
            }
        }

        return longest;
    }

    private String getPalindrome(String s, int left, int right) {
        /*
            left right 两个指针分别指向中心线两侧的元素索引
            如果回文子串有奇数个字符, 中心线是字符, left = right = 中心线索引
            如果回文子串有偶数个字符, 中心线是空隙, left + 1 = right
         */
        while(left >= 0 && right < s.length()) {
            if (s.charAt(left) != s.charAt(right)) {
                break;
            }
            left--;
            right++;
        }
        return s.substring(left + 1, right);
    }
}

class Main {
    public static void main(String[] args) {
        String palindrome = new Solution().longestPalindrome("mabcban");
        System.out.println(palindrome);
    }
}

  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
  
10
  
11
  
12
  
13
  
14
  
15
  
16
  
17
  
18
  
19
  
20
  
21
  
22
  
23
  
24
  
25
  
26
  
27
  
28
  
29
  
30
  
31
  
32
  
33
  
34
  
35
  
36
  
37
  
38
  
39
  
40
  
41
  
42
  
43
  
44
  
45
  
46
  
47
  
48
  
49
  
50
  
51
 

$O(n^2)$ 时间复杂度算法 , 该算法可接受 ;

文章来源: hanshuliang.blog.csdn.net，作者：韩曙亮，版权归原作者所有，如需转载，请联系作者。

原文链接：hanshuliang.blog.csdn.net/article/details/117194338