动态规划 No.5最长回文子串

题目大意

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

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

示例2:

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

方法一：暴力法

寻找string的每一个子串，判断该子串是否为回文子串，并动态地记录最长的回文串长度。寻找子串的时间复杂度为O(n^{2)，判断回文子串的复杂度为O(n)，所以算法的总时间复杂度为O(n}3)。

public String longestPalindrome(String s) {
        char[] arr = s.toCharArray();
        int cnt = 0,max = 0;
        int r_i=0,r_end=0;
        boolean flag = false;
        for(int i=0;i=i;--j) {
                if(isPalindrome(arr,i,j)) {
                flag = true;
                cnt = j - i;
                if(cnt>max) {
                    r_i = i;
                    r_end = j;
                    max = cnt;
                  }
              }
            if(max >= arr.length-i) break;
           }
        }
        if(flag) {
            StringBuffer sb = new StringBuffer();
            while(r_i<=r_end)  
                sb.append(arr[r_i++]);
            return sb.toString();
        }
        return "";
    }
    
private boolean isPalindrome(char[] arr,int i,int j) 
    {
         if(i>j) return false;
         while(i

运行时间388ms,击败11.10%。

方法二：反转字符串

假设原来的字符串为origin，反转后的字符串为reverse，将origin和reverse取交集，得到一个最长公共子串。但是这个方法需要修正。
比如，origin = "abcdacdcba"
reverse = "abcdcadcba"
取交集以后子串为"abcd"，但是该子串并非为回文子串。所以我们求出最长公共子串后，并不一定是回文串，我们还需要判断该字符串倒置前的下标和当前的字符串下标是不是匹配。
比如origin = "caba"，reverse = "abac"，reverse中aba的下标为3 2 1，和origin下标的1 2 3 相互对应。算法结束时，origin和reverse的下标均指向回文串的末尾，而reverse的下标j应该对应未反转的回文子串的开头。
所以对reverse的下标j，我们可以得到如下关系：
beforRev = origin.length() - j -1;
beforRev == i - maxLen +1;
在算法中，我们设置一个二维数组boolean[][] arr,当origin[i] == reverse[j]时，arr[i][j] = arr[i-1][j-1]+1。

public String longestPalindrome(String s) {
        if(s.length()==0) return s;
        String origin = s;
        String reverse = new StringBuffer(s).reverse().toString();
        int[][] arr = new int[s.length()][s.length()];
        int maxLen = 0,maxEnd=0;
        for(int i=0;i maxLen) 
                    {
                        int beforeRev = s.length()-j-1;
                        if(beforeRev == i-arr[i][j]+1) {
                            maxLen = arr[i][j];
                            maxEnd = i;
                        }
                    }
                }
            }
        }
       return s.substring(maxEnd+1-maxLen,maxEnd+1);
}

两层循环，时间复杂度O(n^{2)，空间复杂度O(n}2)。
运行时间121ms,击败32.60%。

方法三：动态规划

设置一个二维数组boolean[][] P, P[i][j]表示序列(i,j)是否为回文串。可以导出以下公式：
P(i,j) = P(i+1,j-1) && S[i] == S[j]
因为需要知道P(i+1,j-1)才能导出P(i,j)，所以i倒序遍历，j顺序遍历。

image.png

public String longestPalindrome(String s) {
         if(s.length()==0) return s;
        int n = s.length(),maxLen=0;
        int left=0,right=0;
        boolean[][] dp = new boolean[n][n];
        for(int i = n-2;i>=0;i--) {
            for(int j = i+1;j

两层循环，时间复杂度O(n^2) ，空间复杂度O(n^2)。运行时间57ms,击败56.62%。

方法四：扩展中心

image.png

遍历每一个元素作为回文字符串的中心，然后向两边扩展，当遇到边界或者不是回文时，该元素的扩展结束。算法需要动态维护一个left, right 下标，记录回文子串的起始位置。

 public String longestPalindrome(String s) {
         if(s==null || s.length()==0) return s;
         int start=0,end=0;
         for(int i=0;i end-start+1) {
                start = i-(len-1)/2;
                end = i+ len/2;
            }
         }   
         return s.substring(start,end+1);
     }
     private int expandLen(String s, int left,int right) {
         while(left>=0 && right < s.length() && s.charAt(left) == s.charAt(right)) {
              --left;
              ++right;
         }
         return right-left-1;
     }

时间复杂度O(n^2)，空间复杂度O(1)。运行时间9ms 97.41%。