5. 最长回文子串-中心扩散、动态规划、马拉车-字节跳动高频题

一、题目描述

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

示例 1：

输入：s = "babad"
输出："bab"
解释："aba" 同样是符合题意的答案。

示例 2：

输入：s = "cbbd"
输出："bb"

二、解题

中心扩散法

中心扩散，找到基准点，向两边扩散查找，两边的值是否相等。分为奇数和偶数基准点。
找到最长长度的子串，返回起始点。

class Solution {
    public String longestPalindrome(String s) {
       if (s == null || s.length() < 1) {
            return "";
        }
        int maxLen = 0;
        int begin = 0;
        for(int i = 0;i<s.length();i++){
            int len1 = extendSubstrings(s,i,i);
            int len2 = extendSubstrings(s,i,i+1);
            int curmaxLen = Math.max(len1,len2);
            if(curmaxLen > maxLen){
                maxLen = curmaxLen;
                begin = i - (curmaxLen - 1)/2;
            }
        }
        return s.substring(begin,begin+maxLen);   
    }
    //回文串的长度
    public int extendSubstrings(String s,int start,int end){
        if(s.length() == 0){
            return 0;
        }
        while(start>=0 && end < s.length() && s.charAt(start) == s.charAt(end)){
            start--;
            end++;
        }
        return end - start - 1;
    }
}

另一种方法

class Solution {
    public String longestPalindrome(String s) {
        if(s == null || s.length() == 0){
            return "";
        }
        char[] sch = s.toCharArray();
        int length = sch.length;
        int maxLen = 0;
        int begin = 0;
        for(int i = 0;i<length;i++){
            //分为奇数和偶数回文串
            int len1 = isPalindrome(sch,i,i);
            int len2 = isPalindrome(sch,i,i+1);
            int curMax = Math.max(len1,len2);
            if(curMax > maxLen){
                maxLen = curMax;
                begin = i - (maxLen - 1)/2;
            }
        }
        return s.substring(begin,begin+maxLen);
    }

    public int isPalindrome(char[] sch,int left,int right){
        if(sch == null || sch.length == 0){
            return 0;
        }
        while(left >= 0 && right < sch.length && sch[left] == sch[right]){
            left--;
            right++;
        }
        return right - left - 1;
    }
}

动态规划

dp[i][j]表示子串s[i…j]是否为回文子串。

状态转移方程：dp[i][j] = (s[i] == s[j]) && (j - i < 2 || dp[i + 1][j - 1]);
边界条件：j-1-(i+1)+1<2，整理为j-i<3；
初始化：dp[i][i] = true；

class Solution {
    public String longestPalindrome(String s) {
       if (s == null || s.length() < 1) {
            return "";
        }
        //动态规划
        int length = s.length();
        boolean[][] dp =new boolean[length][length];
        int maxLen = 1;
        int begin = 0;

        //从左下角开始遍历
        for(int j = 1;j<length;j++){
            for(int i = 0;i<j;i++){
                if(s.charAt(i) != s.charAt(j)){
                    dp[i][j] = false;
                }else{
                    if(j-i <3){
                        dp[i][j] = true;
                    }else{
                        dp[i][j] = dp[i+1][j-1];
                    }
                }

                if(dp[i][j] && j-i+1>maxLen){
                    maxLen = j-i+1;
                    begin = i;
                }
            }
        }
        return s.substring(begin,begin+maxLen);

    }
}

代码二：

class Solution {
    public String longestPalindrome(String s) {
       if (s == null || s.length() < 1) {
            return "";
        }
        //动态规划
        int length = s.length();
        boolean[][] dp =new boolean[length][length];
        int maxLen = 1;
        int begin = 0;

         for (int j = 0; j < length; j++) {
            for (int i = 0; i <= j; i++) {
                if (s.charAt(i) == s.charAt(j) && (j - i < 2 || dp[i + 1][j - 1])) {
                    dp[i][j] = true;   
                }
                if(dp[i][j] && j-i+1>maxLen){
                    maxLen = j-i+1;
                    begin = i;
                }
            }
        }
        return s.substring(begin,begin+maxLen);

    }
}    

马拉车算法

马拉车算法详细讲解看Manacher算法

class Solution {
    public String longestPalindrome(String s) {
        //马拉车算法
        int length = s.length();
        if(length < 2){
            return s;
        }
        String str = addDividers(s,'#');
        int sLen = 2*length+1;
        //p[i] :以预处理字符串下标i为中心的回文半径（奇数长度是不包括中心）
        //p是首字符。
        int[] p = new int[sLen];

        //通过中心扩散的方式能扩散的最右边的下标
        int maxRight = 0;
        //与maxRight对应的中心字符的下标
        int center = 0;

        int maxLen = 1;
        int begin = 0;
        int res = 0;
        char[] charArray = str.toCharArray();
        for(int i = 0;i<sLen;i++){
            if(i < maxRight){
                //状态转移方程
                int mirror = 2 * center - i;
                p[i] = Math.min(maxRight - i,p[mirror]);
            }
            //尝试使用中心扩散法 更新p[i]的值
            int left = i - (1+p[i]);
            int right = i + (1+p[i]);
            while(left>=0 && right<sLen && charArray[left] == charArray[right]){
                p[i]++;
                left--;
                right++;
            }

            //更新maxRight，他是遍历过的i的i+p[i]的最大值
            if(i+p[i] > maxRight){
                //maxRight 和 center同时更新
                maxRight = i + p[i];
                center = i;
            }
            //统计答案，当前(p[i]+1)/2;
            res += ((p[i]+1)/2) ;

            //记录最长回文子串的长度和相应它在原始字符串的起点
            if(p[i] > maxLen){
                maxLen = p[i];
                begin = (i - maxLen) / 2;
            }
        }
        return s.substring(begin,begin+maxLen);
    }

    //预处理字符串
    public String addDividers(String s,char divider){
        if(s.indexOf(divider) != -1){
            return null;
        }
        char[] charArray = s.toCharArray();
        int length = s.length();
        StringBuilder sb = new StringBuilder();
        for(int i = 0;i<length;i++){
            sb.append(divider);
            sb.append(charArray[i]);
        }
        sb.append(divider);
        return sb.toString();
    }
}