LeetCode-5-最长回文子串

题目

来源：LeetCode.

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

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

输入：s = "cbbd"
输出："bb"
示例 3：

输入：s = "a"
输出："a"
示例 4：

输入：s = "ac"
输出："a"

接下来看一下解题思路：

思路一（暴力求解）：

    首先采用双指针法；
    定位一个指针，用另一个指针遍历字符串；
    每遍历一个判断是否是回文字符串，如果是回文子串就记录起始位置和最大长度；
    最后根据起始位置和最大长度截取最长回文子串。
对于单个字符就是回文串，所以不需要判断，所以字符串左边枚举的区间的[ 0 - len -1)；右边枚举区间是[ i + 1, len)；
注：对于找子串问题，需要记录起始位置和长度即可，在最后需要输出的时候截取字符串
代码示例：

//暴力解法，双指针
    public String longestPalindrome(String s) {
        int len = s.length();
        if (len < 2) {
            return s;
        }

        int begin = 0;
        int maxLen = 1;
        char[] chars = s.toCharArray();

        for (int i = 0; i < len - 1; ++i) {
            for (int j = i + 1; j < len; ++j) {
                if (j - i + 1 > maxLen && findPalindromeString(chars, i, j)) {
                    maxLen = j - i + 1;
                    begin = i;
                }
            }
        }

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

    // 判断回文子串
    private static boolean findPalindromeString(char[] chars, int left, int right) {
        while (left < right) {
            if (chars[left] != chars[right]) {
                return false;
            }
            ++left;
            --right;
        }
        return true;
    }

总结

    时间复杂度 O(n^3)，n为字符串的长度，因为在双重for循环里做了一次遍历；
    因为申请了常数个变量，所以空间复杂度 O(1)；

思路二 中心扩散法

    第一种思路是从两边向中心找回文子串，其实 还可以从中间向两边找回文子串，这种方式为中心扩散法；
    首先需要找到回文串的中心位置，分为奇数和偶数两种情况；
    奇数情况：从中间一个字符向两边扩散，直到遇到边界或者回文串不成立的情况，返回回文串的长度；
    偶数情况：从中间两个字符向两边扩散，直到遇到边界或者回文串不成立的情况，返回回文串的长度；
    最后根据回文串的中间位置和长度，计算回文串的起始位置，然后返回最大回文子串；

// 中心扩散法
public static String longestPalindrome(String s) {
    int len = s.length();
    if (len < 2) {
        return s;
    }

    int maxLen = 1;
    int begin = 0;
    char[] chars = s.toCharArray();

    for (int i = 0; i < len - 1; ++i) {
        // 奇数情况
        int odd = spreadAroundCenter(chars, i, i);
        // 偶数情况
        int even = spreadAroundCenter(chars, i, i + 1);

        int curLen = Math.max(odd, even);
        if (curLen > maxLen) {
            maxLen = curLen;
            // 知道中心位置和回文串长度计算回文子串的起始位置（综合奇偶情况）
            begin = i - (maxLen - 1) / 2;
        }
    }

    return s.substring(begin, begin + maxLen);
}
// 从某个点向两边扩展
private static int spreadAroundCenter(char[] chars, int left, int right) {
    while (left >= 0 && right < chars.length && chars[left] == chars[right]) {
        --left;
        ++right;
    }
    // 返回回文串的长度
    return right - left - 1;
}

    时间复杂度：O(n^2))，其中 n 是字符串的长度。长度为 1 和 2 的回文中心分别有 n 和 n−1 个，每个回文中心最多会向外扩展 O(n) 次。
    空间复杂度：O(1)。

思路三 动态规划

    对于一个子串而言，如果它是回文串，并且长度大于 2，那么将它首尾的两个字母去除之后，它仍然是个回文串。例如对于字符串“ababa”，如果我们已经知道 “bab” 是回文串，那么 “ababa” 一定是回文串，这是因为它的首尾两个字母都是 “a”。
     也就是说当前串是不是回文串取决于它的子串，用 dp[i][j] 表示子串 s[i…j] 是否为回文子串，可以得出状态转移方程： dp[i][j] = (s[i] == s[j]) && dp[i + 1] [j - 1], 边界条件： j - 1 - (i + 1) + 1 < 2, 整理得 j - i < 3，归纳为：dp[i][j] = (s[i] == s[j]) and (j - i < 3 or dp[i + 1][ j - 1])
     初始化 dp[i][i] = true, 也就是对角线，表示单个字符，所以是回文串；
     输出：在得到一个状态的值为 true 的时候，记录起始位置和长度，填表完成以后再截取
    由于 dp[i][j] 参考它的左下方的值：
（1）先升序填列
（2）后升序填行

 public static String longestPalindrome(String s) {
    int len = s.length();
    if (len < 2) {
        return s;
    }

    int maxLen = 1;
    int begin = 0;
    char[] chars = s.toCharArray();
    
    boolean[][] dp = new boolean[len][len];
    // 矩阵对角线表示单个字符，所以都为 true
    for (int i = 0; i < dp.length; ++i) {
        dp[i][i] = true;
    }

    // 因为 i 表示字符串的左边， j 表示右边，所以只会用到矩阵的右上边半部分
    for (int j = 1; j < len; ++j) {
        for (int i = 0; i < j; ++i) {
            if (chars[i] != chars[j]) {
                dp[i][j] = false;
            } else {
                if (j - i < 3) { // 表示子串只有一个字符
                    dp[i][j] = true;
                } else {
                    // 当前位置是否是回文串取决于当前字符相等并且和左下位置的值
                    // dp[i][j] = (s[i] == s[j]) && dp[i + 1][j - 1]
                    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);
}

• 时间复杂度：O(n^2)，其中 nn 是字符串的长度。动态规划的状态总数为 O(n^2)，对于每个状态，我们需要转移的时间为 O(1)。

• 空间复杂度：O(n^2)，即存储动态规划状态需要的空间。

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/longest-palindromic-substring/solution/zui-chang-hui-wen-zi-chuan-by-leetcode-solution/
来源：力扣（LeetCode）