LeetCode 刷题记录 5. Longest Palindromic Substring

最新推荐文章于 2020-08-30 16:20:52 发布

dldldl1994

最新推荐文章于 2020-08-30 16:20:52 发布

阅读量239

点赞数

CC 4.0 BY-SA版权

分类专栏： LeetCode

本文链接：https://blog.youkuaiyun.com/dldldl1994/article/details/89077306

LeetCode 专栏收录该内容

80 篇文章

订阅专栏

本文详细介绍了如何解决LeetCode上的5. Longest Palindromic Substring问题，包括四种方法：以字符为中心扩散、优化的扩散法、动态规划和马拉车算法。分别用C++、Java和Python进行了实现，特别强调了边界条件和效率优化。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目：
Given a string s, find the longest palindromic substring in s. You may assume that the maximum length of s is 1000.

Example 1:

Input: “babad”
Output: “bab”
Note: “aba” is also a valid answer.
Example 2:

Input: “cbbd”
Output: “bb”
方法1：
遍历字符串中的每个字符，以每个字符为中心，向外扩散，记录回文字符串起始位置和长度，分字符串为奇数和偶数两种情况
c++：

class Solution {
public:
    int lo = 0;
    int maxLen = 0;
    string longestPalindrome(string s) {
        if(s.size() < 2) return s;
        for(int i = 0; i < s.size() - 1; i++){
            //假设回文字符串为奇数
            findPalindromic(s, i, i);
            //假设回文字符串为偶数
            findPalindromic(s, i, i + 1);
        }
        return s.substr(lo, maxLen);
    }
    void findPalindromic(string s, int left, int right){
        while(left >= 0 && right < s.size() && s[left] == s[right]){
            left--;
            right++;
        }
        if((right - left - 1) > maxLen){
            maxLen = (right - left - 1);
            lo = left + 1;
        }
    }
};

java：
substring函数参数起始位置和结束位置，前闭后开
c++ substr函数参数起始位置和长度

class Solution {
    private int lo = 0;
    private int maxLen = 0;
    public String longestPalindrome(String s) {
        if(s.length() < 2) return s;
        for(int i = 0; i < s.length() - 1; i++){
            //假设回文字符串为奇数
            findPalindromic(s, i, i);
            //假设回文字符串为偶数
            findPalindromic(s, i, i + 1);
        }
        return s.substring(lo, lo + maxLen);
    }
    private void findPalindromic(String s, int left, int right){
        while(left >= 0 && right < s.length() && s.charAt(left) == s.charAt(right)){
            left--;
            right++;
        }
        if((right - left - 1) > maxLen){
            maxLen = (right - left - 1);
            lo = left + 1;
        }
    }
    
}

python:
s[left + 1 : right]中间是冒号

class Solution(object):
    
    
    def longestPalindrome(self, s):
        """
        :type s: str
        :rtype: str
        """
        res = ""
        if len(s) < 2: return s
        for i in xrange(len(s)):
            temp = self.findPalindromic(s, i, i)
            if len(temp) > len(res):
                res = temp
            temp = self.findPalindromic(s, i, i + 1)
            if len(temp) > len(res):
                res = temp
        return res
        
    def findPalindromic(self, s, left, right):
            while left >= 0 and right < len(s) and s[left] == s[right]:
                left -= 1
                right += 1
        
            return s[left + 1 : right]

方法2：
与方法1的不同点

首先判断剩下的长度是否小于maxLen的一半，如果是则不可能是最大长度，直接break
不在考虑奇偶两种情况，首先left 和 right 都指向 i，如果right后面有重复字符，则跳过（对应偶数情况）
最后right指向重复的最后一个元素，如 noon，left指向第一个o，right指向第二个o，对于 bob，不用跳过，left和right都指向o
i不在是+1，而是i = right + 1
判断回文是s[left - 1] == s[right + 1]而不是方法1中s[left] == s[right]，注意边界的处理如果有重复字符，自然s[left] == s[right]成立，自然开始比较s[left - 1] == s[right + 1]，如果没有重复字符，left和right指向的同一个字符，自然相等
判断回文结束后，left和right指向回文串的首尾元素，长度是right - left + 1，从left开始，方法1，left和right指向回文串的首尾元素的前一个元素和后一个元素，长度是right - left - 1，从left + 1开始

class Solution {
public:
    string longestPalindrome(string s) {
        if(s.size() < 2) return s;
        int n = s.size();
        int lo = 0;
        int maxLen = 0;
        for(int i = 0; i < n;){
            if((n - i) <= (maxLen / 2)) break;
            int left = i, right = i;
            while(right < (n - 1) && s[right] == s[right + 1]) right++;
            i = right + 1;
            while(left > 0 && right < (n - 1) && s[left - 1] == s[right + 1]){
                left--;
                right++;
            }
            if(maxLen < (right - left + 1)){
                maxLen = (right - left + 1);
                lo = left;
            }
        }
        return s.substr(lo, maxLen);
    }
   
};

java:

class Solution {
    
    public String longestPalindrome(String s) {
        if(s.length() < 2) return s;
        int n = s.length();
        int lo = 0;
        int maxLen = 0;
        for(int i = 0; i < n;){
            if((n - i) <= (maxLen / 2)) break;
            int left = i, right = i;
            while(right < (n - 1) && s.charAt(right) == s.charAt(right + 1)) right++;
            i = right + 1;
            while(left > 0 && right < (n - 1) && s.charAt(left - 1) == s.charAt(right + 1)){
                left--;
                right++;
            }
            if(maxLen < (right - left + 1)){
                maxLen = (right - left + 1);
                lo = left;
            }
        }
        return s.substring(lo, lo + maxLen);
    }
    
    
}

python:

class Solution(object):
    
    
    def longestPalindrome(self, s):
        """
        :type s: str
        :rtype: str
        """
        n = len(s) 
        lo, maxLen = 0, 0
        if len(s) < 2: return s
        for i in xrange(len(s)):
            if (n - i) <= (maxLen / 2): break
            left = right = i
            while right < (n - 1) and s[right] == s[right + 1]: right += 1;
            i = right + 1
            while left > 0 and right < (n - 1) and s[left - 1] == s[right + 1]:
                left -= 1
                right += 1
            
            if maxLen < (right - left + 1):
                maxLen = (right - left + 1)
                lo = left
            
        
        return s[lo : lo + maxLen]

方法3：动态规划法
dp[i][j]代表从i开始，到j结束的字符串，为0，表示不是回文串，为1是回文串

i=j，只有一个字符，自然是回文串
i + 1 = j ，i，j相邻，如果满足s[i] == s[j] 是回文串
j - i >= 2 如果满足s[i] == s[j]并且dp[i+1][j-1]是回文串，才是回文串
c++:
maxLen需初始设置为1，因为maxLen只在内层循环更新，如果设为0
s= “ac”,则输出为空串，错误

class Solution {
public:
    string longestPalindrome(string s) {
        if(s.size() < 2) return s;
        int n = s.size();
        int lo = 0;
        int maxLen = 1;
        int dp[n][n] = {0};
        
        for(int i = 0; i < n; i++){
            dp[i][i] = 1;
            
            for(int j = 0; j < i; j++){
                dp[j][i] = (s[i] == s[j]) && (((i - j) < 2) || dp[j + 1][i - 1]);
                if(dp[j][i] && maxLen < (i - j + 1)){
                    lo = j;
                    maxLen = (i - j + 1);
                }
            }
            
        }
        return s.substr(lo, maxLen);
    }
   
};

java:
特别注意java中bool和int不能转换
int数组默认值为0

class Solution {
    
    public String longestPalindrome(String s) {
        if(s.length() < 2) return s;
        int n = s.length();
        int lo = 0;
        int maxLen = 1;
        int[][] dp = new int[n][n];
        
        for(int i = 0; i < n; i++){
            dp[i][i] = 1;
            
            for(int j = 0; j < i; j++){
                if((s.charAt(i) == s.charAt(j)) && (((i - j) < 2) || dp[j + 1][i - 1] == 1)){
                    dp[j][i] = 1;
                }
                
                if(dp[j][i] == 1 && maxLen < (i - j + 1)){
                    lo = j;
                    maxLen = (i - j + 1);
                }
            }
            
        }
        return s.substring(lo, lo + maxLen);
    }
    
    
}

python:
创建二维数组 dp = [[0] * n for i in range(n)]
不应 dp = [[0] * n ] *n

class Solution(object):
    
    
    def longestPalindrome(self, s):
        """
        :type s: str
        :rtype: str
        """
        n = len(s) 
        lo, maxLen = 0, 1
        if len(s) < 2: return s
        dp = [[0] * n for i in range(n)]
        for i in xrange(len(s)):
            dp[i][i] = 1
            j = 0
            while j < i:
                dp[j][i] = (s[i] == s[j]) and (((i - j) < 2) or dp[j + 1][i - 1])
                if dp[j][i] and maxLen < (i - j + 1):
                    lo = j
                    maxLen = (i - j + 1)
                
                j += 1
             
            
        
        return s[lo : lo + maxLen]

方法4：
马拉车算法 Manacher’s Algorithm将时间复杂度提升到了O(n)
马拉车算法
C++:
注意点：string末尾自动加\0,故不用手动加

class Solution {
public:
    string longestPalindrome(string s) {
        string t = "$#";
        for(int i = 0; i < s.size(); i++){
            t += s[i];
            t += "#";
        }
        vector<int> p(t.size(), 0);
       // int p[t.size()] = {0};
        int id = 0, mx = 0, resCenter = 0, resLen = 0;
        for(int i = 1; i < t.size(); i++){
            p[i] = (mx > i) ? min(p[2 * id - i], mx - i) : 1;
            while(t[i + p[i]] == t[i - p[i]]) p[i]++;
            if(i + p[i] > mx){
                id = i;
                mx = (i + p[i]);
            }
            if(p[i] > resLen){
                resCenter = i;
                resLen = p[i];
            }
        }
        
        return s.substr((resCenter - resLen) / 2, resLen - 1);
    }
   
};

java：

使用StringBuilder 而不是String 因为String 只有+操作，会创建新的对象，耗时间和空间用StringBuilder则没有此问题
String后没\0,手动加，同时i < t.length() - 1，相应减一位

class Solution {
    
    public String longestPalindrome(String s) {
        StringBuilder t = new StringBuilder("$#");
        for(int i = 0; i < s.length(); i++){
            t.append(s.charAt(i));
            t.append("#");
        }
        t.append("\0");
        //System.out.println(t);
        
       // int p[t.size()] = {0};
        int[] p = new int[t.length()];
        int id = 0, mx = 0, resCenter = 0, resLen = 0;
        for(int i = 1; i < t.length() - 1; i++){
            p[i] = (mx > i) ? Math.min(p[2 * id - i], mx - i) : 1;
            while(t.charAt(i + p[i]) == t.charAt(i - p[i])) p[i]++;
            //System.out.println("i是"+i+"p[i]是"+p[i]);
            if(i + p[i] > mx){
                id = i;
                mx = (i + p[i]);
            }
            if(p[i] > resLen){
                resCenter = i;
                resLen = p[i];
            }
        }
        
        return s.substring((resCenter - resLen) / 2, (resCenter - resLen) / 2 + resLen - 1);
    }
    
    
}

python:
python可以连等

class Solution(object):
    
    
    def longestPalindrome(self, s):
        """
        :type s: str
        :rtype: str
        """
        t = "$#"
        for i in xrange(len(s)):
            t += s[i]
            t += "#"
        t += "\0"
        p = [0] * len(t)
        id = mx = resCenter = resLen = 0
        for i in range(1, len(t) - 1):
            p[i] = min(p[2 * id - i], mx - i) if (mx > i) else 1
            while t[i + p[i]] == t[i - p[i]]: p[i] += 1
            if i + p[i] > mx:
                id = i
                mx = (i + p[i])
            
            if p[i] > resLen:
                resCenter = i
                resLen = p[i]
            
        return s[(resCenter - resLen) / 2 : (resCenter - resLen) / 2 + resLen - 1]