LeetCode 5. 最长回文子串

思路

方法一：暴力法，双重循环判断

class Solution {
public:
    //暴力法，时间复杂度O(n^2)，提交之后会超时，不能accept
    string longestPalindrome(string s) {
        int slen = s.length();
        string maxPalindrome(1, s[0]);
        for(int i = 0; i <= slen-2; ++i) {
            for(int j = i+1; j <= slen-1; ++j) {
                if(s[i] == s[j] && isPalindrome(s, i, j)) {
                    if(j-i+1 > maxPalindrome.length())
                        maxPalindrome = s.substr(i, j-i+1);
                }
            }
        }

        return maxPalindrome;
    }

    //判断回文串
    bool isPalindrome(const string& s, int i, int j) {
        while(i < j) {
            if(s[i] != s[j]) {
                return false;
            }

            ++i;
            --j;
        }

        return true;
    }
};

复杂度分析：

时间复杂度：O(n³)，双重循环嵌套一个判断回文串的函数，双重循环是O(n²)，判断回文串是O(n)。

方法二：动态规划

class Solution {
public:
    string longestPalindrome(string s) {
        int slen = s.length();
        string maxPalindrome(1, s[0]);  //初始化为第一个字符
        vector<vector<bool>> dp(slen, vector<bool>(slen, false));

        for(int len = 0; len < slen; ++len) {
            for(int i = 0; i + len < slen; ++i) {
                int j = i+len;
                if(j-i == 0) {
                    dp[i][j] = true;
                } else if(j-i == 1) {
                    dp[i][j] = (s[i] == s[j]);
                } else {
                    dp[i][j] = (s[i] == s[j] && dp[i+1][j-1]);
                }

                if(dp[i][j] && j-i+1 > maxPalindrome.length()) {
                    maxPalindrome = s.substr(i, j-i+1);
                }
            }
        }
        

        return maxPalindrome;
    }
};

方法三：中心扩展算法

class Solution {
public:
    string longestPalindrome(string s) {
        int start = 0, end = 0;
        for (int i = 0; i < s.length(); i++) {
            int len1 = expandAroundCenter(s, i, i);
            int len2 = expandAroundCenter(s, i, i + 1);
            int len = max(len1, len2);
            if (len > end - start) {
                start = i - (len - 1) / 2;
                end = i + len / 2;
            }
        }
        return s.substr(start, end - start + 1);
    }

    int expandAroundCenter(const string& s, int left, int right) {
        while (left >= 0 && right < s.length() && s[left] == s[right]) {
            --left;
            ++right;
        }
        return right - left - 1;
    }
};

 

方法四：Manacher 算法 （马拉车算法）

还有一个复杂度为 O(n)Manacher 算法。然而本算法十分复杂，一般不作为面试内容。这里给出，仅供有兴趣的同学挑战自己。

具体见：LeetCode官方题解 - 最长回文子串

参考

本文转载自：LeetCode官方题解 - 最长回文子串