Leetcode No.5 最长回文子串

给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。

示例 1：

输入: "babad"
输出: "bab"
注意: "aba" 也是一个有效答案。
示例 2：

输入: "cbbd"
输出: "bb"

方法一：暴力匹配 （Brute Force）

根据回文子串的定义，枚举所有长度大于等于 2 的子串，依次判断它们是否是回文；
在具体实现时，可以只针对大于“当前得到的最长回文子串长度”的子串进行“回文验证”；
在记录最长回文子串的时候，可以只记录“当前子串的起始位置”和“子串长度”，不必做截取。这一步我们放在后面的方法中实现。
说明：暴力解法时间复杂度高，但是思路清晰、编写简单。由于编写正确性的可能性很大，可以使用暴力匹配算法检验我们编写的其它算法是否正确。优化的解法在很多时候，是基于“暴力解法”，以空间换时间得到的，因此思考清楚暴力解法，分析其缺点，很多时候能为我们打开思路。

package longest_palindrome;

public class Solution {
    public boolean isPalindrome(char[] charArray, int left, int right){
        while(left<right){
            if(charArray[left]!=charArray[right]){
                return false;
            }
            left++;
            right--;
        }
        return true;
    }
    public String longestPalindrome(String s) {
        int len=s.length();
        if(len<2){
            return s;
        }
        int maxLen=1;
        int begin=0;
        //s.charAt(i) 每次都会检查数组下标越界，因此先转换成字符数组
        char[] charArray = s.toCharArray();
        for(int i=0;i<len-1;i++){
            for(int j=i+1;j<len;j++){
                if(isPalindrome(charArray,i,j)&&j-i+1>maxLen){
                    maxLen=j-i+1;
                    begin=i;
                }
            }
        }
        return s.substring(begin,begin+maxLen);
    }

    public static void main(String[] args) {
        Solution solution=new Solution();
        System.out.println(solution.longestPalindrome("bb"));
    }
}

复杂度分析：

时间复杂度：O(N^3)，这里 N 是字符串的长度，枚举字符串的左边界、右边界，然后继续验证子串是否是回文子串，这三种操作都与 N 相关；
空间复杂度：O(1)，只使用到常数个临时变量，与字符串长度无关。

方法二：动态规划

对于一个子串而言，如果它是回文串，并且长度大于 2，那么将它首尾的两个字母去除之后，它仍然是个回文串。例如对于字符串 “ababa”，如果我们已经知道“bab” 是回文串，那么 “ababa” 一定是回文串，这是因为它的首尾两个字母都是“a”。

根据这样的思路，我们就可以用动态规划的方法解决本题。我们用 P(i,j) 表示字符串 s 的第 i 到 j 个字母组成的串（下文表示成 s[i:j]）是否为回文串：

这里的「其它情况」包含两种可能性：

s[i, j]s[i,j] 本身不是一个回文串；

i>j，此时s[i,j] 本身不合法。

那么我们就可以写出动态规划的状态转移方程：

P(i, j) = P(i+1, j-1) &&(Si == Sj)

也就是说，只有s[i+1:j−1] 是回文串，并且 s 的第 i 和 j 个字母相同时，s[i:j] 才会是回文串。

上文的所有讨论是建立在子串长度大于 2 的前提之上的，我们还需要考虑动态规划中的边界条件，即子串的长度为 1 或 2。对于长度为 1 的子串，它显然是个回文串；对于长度为 2 的子串，只要它的两个字母相同，它就是一个回文串。因此我们就可以写出动态规划的边界条件：

根据这个思路，我们就可以完成动态规划了，最终的答案即为所有 P(i,j)=true 中 j-i+1（即子串长度）的最大值。注意：在状态转移方程中，我们是从长度较短的字符串向长度较长的字符串进行转移的，因此一定要注意动态规划的循环顺序。

class Solution {
    public String longestPalindrome(String s) {
       int n=s.length();
       String rs="";
       boolean[][] dp=new boolean[n][n];
       for(int k=0;k<n;k++){
           for(int i=0;i+k<n;i++){
               int j=i+k;
               if(k==0){
                   dp[i][j]=true;
               }else if(k==1){
                   dp[i][j]=(s.charAt(i)==s.charAt(j));
               }else{
                   dp[i][j]=dp[i+1][j-1]&&(s.charAt(i)==s.charAt(j));
               }
               if(dp[i][j]&&((k+1)>rs.length())){
                   rs=s.substring(i,j+1);
                   System.out.println(rs);
               }
           }
       }
       return rs;
    }
}

复杂度分析

时间复杂度：O(n^2)，其中 n是字符串的长度。动态规划的状态总数为 O(n^2)，对于每个状态，我们需要转移的时间为 O(1)。

空间复杂度：O(n^2)，即存储动态规划状态需要的空间。

欢迎关注微信公众号【算法攻城师】