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

Posted 2022-04-18 hequnwang10

一、题目描述

给你一个字符串 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;
    

动态规划

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();