【NO.5】LeetCode HOT 100—5. 最长回文子串

5. 最长回文子串

5. 最长回文子串

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

如果字符串的反序与原始字符串相同，则该字符串称为回文字符串。

示例 1：

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

输入：s = “cbbd”
输出：“bb”

提示：

1 <= s.length <= 1000
s 仅由数字和英文字母组成

解题

方法一：动态规划

动态规划，dp[i][j] 表示从i到j是回文。

状态转移方程：P(i,j)=P(i+1,j−1)∧(Si==Sj)
也就是说，只有 s[i+1:j−1] 是回文串，并且 s 的第 i 和 j 个字母相同时，s[i:j]s[i:j]s[i:j] 才会是回文串。

注意：在状态转移方程中，我们是从长度较短的字符串向长度较长的字符串进行转移的，因此一定要注意动态规划的循环顺序。

最终的答案即为所有 P(i,j)=true中 j−i+1（即子串长度）的最大值

// 时间O(n^2)，空间O(n^2)
class Solution {
    public String longestPalindrome(String s) {
        int length = s.length();
        if (length < 2) {
            return s;
        }
        boolean[][] dp = new boolean[length][length];
        // 最长回文长度一开始为1
        int maxLength = 1;
        int index = 0;
         // 将字符串转为char数组，方便遍历
        char[] chars = s.toCharArray();
        // 特殊 对角线肯定是
        for (int i = 0; i < length; i++) {
            dp[i][i] = true;
        }

        // 遍历上三角就行,注意这里的遍历方式，为了dp的连贯性，要从列开始
        for (int j = 1; j < length; j++) {
            for (int i = 0; i < j; i++) {
                if (chars[i] != chars[j]) {
                    dp[i][j] = false;
                } else {
                    if ((j-i+1) <= 3) {
                        // 此时长度小于3, 两个字符又相等，那必是
                        dp[i][j] = true;
                    } else {
                        dp[i][j] = dp[i+1][j-1];
                    } 
                }

                // 标记完，统计最长
                if (dp[i][j] && (j-i+1) > maxLength) {
                    maxLength = j-i+1;
                    index = i;
                }
            }
        }
        // 截取字符串，两个的下标
        return s.substring(index, index+maxLength);
    }
}

方法二：中心扩展

中心扩散法怎么去找回文串？

从每一个位置出发，向两边扩散即可。遇到不是回文的时候结束。

举个例子，str=acdbbdaastr = acdbbdaastr=acdbbdaa 我们需要寻找从第一个 b（位置为 333）出发最长回文串为多少。怎么寻找？

• 首先往左寻找与当期位置相同的字符，直到遇到不相等为止。
• 然后往右寻找与当期位置相同的字符，直到遇到不相等为止。
• 最后左右双向扩散，直到左和右不相等。如下图所示：

每个位置向两边扩散都会出现一个窗口大小（tempLen ）。如果 tempLen >maxLen(用来表示最长回文串的长度）。则更新 maxLen 的值。

因为我们最后要返回的是具体子串，而不是长度，因此，还需要记录一下 maxLen 时的起始位置（maxStart），即此时还要 maxStart=len。

// 时间O(n^2)，空间O(1)
class Solution {
    // 中心扩展法
    public String longestPalindrome(String s) {
        int length = s.length();
        if (length < 2) {
            return s;
        }
        int left = 0;
        int right = 0;
        // 记录每一次扩展的长度
        int tempLen = 1;
        // 满足题意的最长的下标开始
        int maxStart = 0;
        int maxLen = 0;

        // 从第一个字符开始扩展
        for (int i = 0; i < length; i++) {
            // 一开始先扩展下左右
            left = i-1;
            right = i+1;
            // 判断相邻字符相等的情况
            while (left >= 0 && s.charAt(left) == s.charAt(i)) {
                tempLen++;
                left--;
            }
            while (right < length && s.charAt(right) == s.charAt(i)) {
                tempLen++;
                right++;
            }
            // 判断边界两个字符是否相等
            while (left >= 0 && right < length && s.charAt(left) == s.charAt(right)) {
                tempLen = tempLen+2;
                left--;
                right++;
            }
            if (tempLen > maxLen) {
                maxLen = tempLen;
                maxStart = left;
            }
            // 遍历下一个时，要重置长度
            tempLen = 1;
        }

        // 因为满足条件时，上面的left right 减1，加1，比实际的字符串边界要大1，所以需要减去
        return s.substring(maxStart+1, maxStart+1+maxLen);
    }
}