LeetCode5 最长回文子串

最长回文子串

给你一个字符串 s，找到 s 中最长的回文子串。

暴力解法

    /**
     * 暴力解法
     * @param s
     * @return
     */
    public static String longestPalindrome(String s) {
        if (s.length()<2){
            return s;
        }
        char[] chars = s.toCharArray();
        int maxLen = 1;
        int begin = 0;
        for (int i = 0; i < chars.length-1 ; i++) {
            for (int j = i+1; j < chars.length ; j++) {
                if (j-i+1>maxLen && validPalindromic(chars, i, j)){
                    maxLen = j-i+1;
                    begin = i;
                }
            }

        }

        return s.substring(begin,begin+maxLen);
    }
    static boolean  validPalindromic(char[] chars,int left, int right){
        while(left<=right){
            if (chars[left] != chars[right])
                return false;
            left++;
            right--;
        }
        return true;
    }

中心扩散解法

    /**
     * 中心扩散
     * 问题 考虑到了 左索引 和 长度 相加计算右索引时需要-1 但没考虑到subString的参数是左闭右开 粗心!!
     * @param s
     * @return
     */
    public static String longestPalindrome2(String s) {
        if (s.length() < 2){
            return s;
        }
        int maxLen = 1;
        int begin = 0;
        char[] chars = s.toCharArray();
        for (int i = 0; i < chars.length-1; i++) {
        	// 获取以 i 为中心的最长字串的长度
            int oddLen = getCenterLength(chars,i,i);
            // 获取以(i,i+1)为中心的最长字串的长度
            int evenLen = -1;
            if (chars[i] == chars[i+1]){
                evenLen = getCenterLength(chars,i,i+1);
            }
            // 获取两者中大的那一个
            int curMax = Math.max(oddLen, evenLen);
            if (curMax>maxLen){
            // 通过计算获得开始坐标和长度
                maxLen = curMax;
                begin = i - (maxLen-1)/2;
            }
        }

        return s.substring(begin,begin+maxLen);
    }

    static int getCenterLength(char[] chars, int left, int right){
        while (left >= 0 && right<chars.length && chars[left] == chars[right]){
                left--;
                right++;
        return right-left-1;
    }

动态规划

找到最后一步 即在一个回文子串的左右同时扩散一位
left < right left=right时为回文子串
创建一个二维数组用于标记left–>right的字符串是否为回文串
确定状态转移方程 f(left,right) = f(left+1,right-1)&&s.indexOf(left) == s.indexOf(right)
同时需要考虑到left+1 > right-1 的特殊情况

 public static String longestPalindrome3(String s) {
        // todo 最长回文子串 动态规划
        int len = s.length();
        boolean[][] isPld = new boolean[len][len];
        for (int right = 0; right < len; right++) {
            isPld[right][right] = true;
            for (int left = right - 1; left >= 0; left--) {
                if (s.charAt(left) == s.charAt(right) ) {
                    if (right-left==1){
                        isPld[left][right] = true;
                    }else if (isPld[left + 1][right - 1])
                    isPld[left][right] = true;
                }
            }
        }
        int start = 0, maxLen = 0;

        for (int right = 0; right < len; right++) {
            for (int left = right; left >= 0; left--) {
                if (isPld[left][right] && right-left+1>maxLen){
                    maxLen = right-left+1;
                    start = left;
                }
            }
        }

        return s.substring(start,start+maxLen);
    }