【LeetCode题解-005】longest Palindrome Substring

题目

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"

原题地址：https://leetcode.com/problems/longest-palindromic-substring/

翻译

给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为1000。

解法

解法一：最长公共子串

我们自然的会想到 如下解法

反转 SS，使之变成 S’S′。找到 SS 和 S’S′ 之间最长的公共子串，这也必然是最长的回文子串。

但是这样的做法会有个问题：

Example 1:
s = 'caba', s1 = 'abac'
s s1 之间的最长公共子串为：'aba'
满足条件
Example 2:
s = 'abacdfgdcaba', s1 = 'abacdgfdcaba'
s s1 之间的最长公共子串为：'abacd'
但是这个字符串并不是回文字符串

我们可以看到，当 SS 的其他部分中存在非回文子串的反向副本时，最长公共子串法就会失败。为了纠正这一点，每当我们找到最长的公共子串的候选项时，都需要检查子串的索引是否与反向子串的原始索引相同。如果相同，那么我们尝试更新目前为止找到的最长回文子串；如果不是，我们就跳过这个候选项并继续寻找下一个候选。

这给我们提供了一个复杂度为 O(n^2)动态规划解法，它将占用 O(n^2)的空间（可以改进为使用 O(n)的空间）。

可以在地址 https://en.wikipedia.org/wiki/Longest_common_substring_problem 阅读更多关于最长公共子串的内容。

此处便不再赘述了！

解法二：暴力法

选出所有子字符串可能的开始和结束位置，并检验它是不是回文。

• 当字符串中字符出现次数为偶数时，必然可以加入最长回文子串
• 当字符串中字符出现次数为奇数时，分情况讨论：
  • 如果出现次数为大于1的奇数n，则可以加入n-1个对应字符到最长回文子串，
  • 最终的最长回文子串，最中间还可以加入一个单一字符
  • 上面两条合并起来，即可以直接将出现最大奇数次数的字符都加入最长回文子串
  • 即if（出现奇数次数的字符数==0），return s.length()
  • if(出现奇数次数的字符数!=0),return s.length()- 出现奇数次数的字符数+1

解法三：动态规划

为了改进暴力法，我们首先观察如何避免在验证回文时进行不必要的重复计算。考虑 ’ ababa’ 这个示例。如果我们已经知道 ‘bab’ 是回文，那么很明显，‘ababa’ 一定是回文，因为它的左首字母和右尾字母是相同的。

我们给出 P(i,j)P(i,j) 的定义如下：

这产生了一个直观的动态规划解法，我们首先初始化一字母和二字母的回文，然后找到所有三字母回文，并依此类推…

/**
     * 动态规划算法
     *
     * @param s
     * @return
     */
public static String longestPalindrome(String s) {
    if (s == null || s.length() < 2) {
        return s;
    }

    int maxLength = 0;
    String longest = null;

    int length = s.length();
    boolean[][] table = new boolean[length][length];

    // 单个字符都是回文
    for (int i = 0; i < length; i++) {
        table[i][i] = true;
        longest = s.substring(i, i + 1);
        maxLength = 1;
    }

    // 判断两个字符是否是回文
    for (int i = 0; i < length - 1; i++) {
        if (s.charAt(i) == s.charAt(i + 1)) {
            table[i][i + 1] = true;
            longest = s.substring(i, i + 2);
            maxLength = 2;
        }
    }

    // 求长度大于2的子串是否是回文串
    for (int len = 3; len <= length; len++) {
        for (int i = 0, j; (j = i + len - 1) <= length - 1; i++) {
            if (s.charAt(i) == s.charAt(j)) {
                table[i][j] = table[i + 1][j - 1];
                if (table[i][j] && maxLength < len) {
                    longest = s.substring(i, j + 1);
                    maxLength = len;
                }
            } else {
                table[i][j] = false;
            }
        }
    }
    return longest;
}

解法四：中心扩展算法

事实上，只需使用恒定的空间，我们就可以在 O(n^2) 的时间内解决这个问题。这也是官网的一种经典解法

我们观察到回文中心的两侧互为镜像。因此，回文可以从它的中心展开，并且只有 2n - 1个这样的中心。

你可能会问，为什么会是 2n - 12n−1 个，而不是 nn 个中心？原因在于所含字母数为偶数的回文的中心可以处于两字母之间（例如 'abba’的中心在两个 ‘b’ 之间）。

/**
     * 中心扩展算法
     * 回文中心的两侧互为镜像。因此，回文可以从它的中心展开，并且只有 2n - 12n−1 个这样的中心。
     * 时间复杂度：由于围绕中心来扩展回文会耗去 O(n)O(n) 的时间O(n^2)
     * 空间复杂度：O(1)
     * @param s
     * @return
     */
public static String longestPalindrome2(String s) {
    if (s == null || s.length() < 1) {
        return "";
    }
    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 = Math.max(len1, len2);
        if (len > end - start) {
            start = i - (len - 1) / 2;
            end = i + len / 2;
        }
    }
    return s.substring(start, end + 1);
}
private static int expandAroundCenter(String s, int left, int right) {
    int L = left, R = right;
    while (L >= 0 && R < s.length() && s.charAt(L) == s.charAt(R)) {
        L--;
        R++;
    }
    return R - L - 1;
}

解法五：Manacher 算法

这是LeetCode官网上的一种复杂度只到 O（n）的解法，可以说是屌炸天了，膜拜中… …

如果你感兴趣的话可以了解一下，地址在这里：https://articles.leetcode.com/longest-palindromic-substring-part-ii/

题外话：由于本人最近工作比较忙，所以刷题数量可能会稍微降低一点，但是会保证一周最少3-4题，共勉！

Github地址：https://github.com/Bylant/LeetCode

CSDN地址：https://blog.csdn.net/ZBylant
微信公众号