LeetCode题解——最长回文子串

LeetCode题解——最长回文子串

我的LeetCode代码集：https://github.com/cnamep001/LeetCode

原题链接：https://leetcode-cn.com/problems/longest-palindromic-substring/description/

题目描述：

思路一：用二维数组

对于动态规划这一思路而言，思路四中时间复杂度的过高，一定是状态定义选择不当。我们换一种状态定义方法。

状态定义：f(x, y)表示区间[x, y]范围的子串是否是回文子串。

状态转移：如果[x + 1, y - 1]范围的子串是回文子串且s.charAt(x) == s.charAt(y)，那么f(x, y)范围的子串就是回文子串。否则，不是回文子串。

在求得这个二维数组后，我们只需要找到该二维数组中y - x差值最大且值为true的元素即找到了我们所要求的回文子串。那这怎么找呢？我们从这个二维数组的右上角按着(0 , n - 1) -> (0, n - 2) -> (1, n - 1) -> (0, n - 3) -> (1, n - 2) -> (2, n - 1)……的顺序一步步遍历，找到第一个为true的元素即可。

显然，该方法只有2重循环，时间复杂度是O(n ^ 2)级别的。而对于空间复杂度，和思路四一样，也是O(n ^ 2)级别的。

实现代码:

package com.m.longest_palindromic_substring.solution1;


public class Solution1 {

    public String longestPalindrome(String s) {
        if (s.length() < 2) {
            return s;
        }
        if (s.length() == 2) {
            if (s.charAt(0) == s.charAt(1)) {
                return s;
            } else {
                return s.substring(0, 1);
            }
        }
        int n = s.length();
        boolean[][] isPalindrome = new boolean[n][n];
        for (int i = 0; i < n; i++) {
            isPalindrome[i][i] = true;
        }
        for (int i = n - 2; i >= 0; i--) {
            for (int j = i + 1; j < n; j++) {
                if (s.charAt(i) == s.charAt(j) && (isPalindrome[i + 1][j - 1] || j - i <= 2)) {
                    isPalindrome[i][j] = true;
                }
            }
        }
        String result = s.substring(0, 1);
        for (int k = -n + 1; k <= -1; k++) {
            for (int i = 0; i < n - 1; i++) {
                if (i - k < n && isPalindrome[i][i - k]) {
                    return s.substring(i, i - k + 1);
                }
            }
        }
        return result;
    }

}

LeetCode解题报告：

思路二：中心向两边一起扩展

这个思路是参考某位博主的一个思路（给出链接：https://www.cnblogs.com/zhangboy/p/6505496.html）
可惜的是这位博主的思路虽然正确，但是他提供的Java代码却是错误的。这也提示我们参考某篇博文的时候一定要先运行一下他的代码，万一他的代码错了，我们或许可以选择不看这篇博文，因为他的思路很可能也是错误的。很庆幸至少那篇博文的思路是可行的。

思路一和思路二都是固定子串的一端去寻找子串的另一端，再来判断寻找到的子串是否是回文串。事实上我们完全可以换一种思路，对于字符串s中的每一个字符，我们假定它是回文串的中间字符，我们向该字符串的两边一起延伸，直到某一边不能延伸或者两边的字符不相等为止。

但要注意的是，回文串的中心分为两种情况，对于奇数回文串，其中心是某个字符，而对于偶数回文串，其中心是两个字符。另外，对于偶数回文串，我们可以让该字符和该字符的前一个字符组成回文串的中心，也可以让该字符和该字符的后一个字符组成回文串的中心，这又是两种情况。

这种方法实现的时间复杂度是O(n ^ 2)级别的，其中n为字符串s的长度。而空间复杂度，我们对于每一个s中的字符都需要保存三种情况得到的字符串，所以空间复杂度应该是O(n)级别的。

实现代码:

package com.m.longest_palindromic_substring.solution2;


public class Solution2 {

    public String longestPalindrome(String s) {
        if (s.length() < 2) {
            return s;
        }
        if (s.length() == 2) {
            if (s.charAt(0) == s.charAt(1)) {
                return s;
            } else {
                return s.substring(0, 1);
            }
        }
        String result = "";
        for (int i = 1; i < s.length() - 1; i++) {
            String odd = maxOddPalindrome(s, i - 1, i + 1);
            String even1 = maxEvenPalindrome(s, i - 1, i);
            String even2 = maxEvenPalindrome(s, i, i + 1);
            if (odd.length() > even1.length()) {
                if (even2.length() > odd.length() && even2.length() > result.length()) {
                    result = even2;
                } else if (odd.length() > result.length()) {
                    result = odd;
                }
            } else {
                if (even2.length() > even1.length() && even2.length() > result.length()) {
                    result = even2;
                } else if (even1.length() > result.length()) {
                    result = even1;
                }
            }
        }
        return result;
    }

    private String maxOddPalindrome(String s, int k, int j) {
        while (k >= 0 && j < s.length() && s.charAt(k) == s.charAt(j)) {
            k--;
            j++;
        }
        return s.substring(k + 1, j);
    }

    private String maxEvenPalindrome(String s, int k, int j) {
        while (k >= 0 && j < s.length() && s.charAt(k) == s.charAt(j)) {
            k--;
            j++;
        }
        return s.substring(k + 1, j);
    }

}

LeetCode解题报告：

思路三：循环

第一重循环，我们的i不需要遍历到字符串s最末的位置，只需遍历到s.length() - result.length()位置即可，因为再往下找，就算找到了回文串，长度也肯定比之前找到的回文串要小。

在第二重循环，我们改为从后往前遍历，一旦找到了回文串，直接break跳出第二重循环进入下一轮的第一重循环。因为是从后往前遍历，接下来在第二重循环中找到的回文串长度肯定比第一次找到的要小。

这个思路的时间复杂度在最坏情况下显然是和思路一样的，是O(n ^ 3)级别的时间复杂度，但平均而言是比思路一要好的。空间复杂度显然也和思路一一样，是O(1)级别的。

实现代码:

package com.m.longest_palindromic_substring.solution3;



public class Solution3 {

    public String longestPalindrome(String s) {
        String result = "";
        for (int i = 0; i < s.length() - result.length(); i++) {
            for (int j = s.length() - 1; j >= i; j--) {
                if(isPalidrome(s.substring(i, j + 1)) && (j + 1 - i) > result.length()) {
                    result = s.substring(i, j + 1);
                    break;
                }
            }
        }
        return result;
    }

    private boolean isPalidrome(String s) {
        for (int i = 0; i < s.length() / 2; i++) {
            if(s.charAt(i) != s.charAt(s.length() - i - 1)) {
                return false;
            }
        }
        return true;
    }

}

LeetCode解题报告：