力扣 Top100 5. 最长回文子串

题目来源：https://leetcode-cn.com/problems/longest-palindromic-substring/

大致题意：
给一个字符串，求出其最长的回文子串

思路

可以直接使用动态规划，使用一个 n*n 的二维数组 dp[i][j] 表示 i - j 的子串是否是回文串

动态规划

使用 dp[i][j] 表示 i-j 的子串是否为回文串，那么

• 若 i 位字符与 j 位字符不相等，显然不为回文串，dp[i][j] 为 false
• 若 i 位字符与 j 位字符相等，若此时子串长度小于等于 3，则子串一定为回文串；否则 dp[i][j] 的值即为 dp[i+1][j-1] 的值

算法过程为：

1. 使用 n*n 的二维布尔数组 dp[i][j] 表示 i - j 的子串是否是回文串，并存下目前的最长回文子串，初始时，dp[i][i] 为 true
2. 从长度 2 遍历到长度 n
3. 每次遍历，都遍历当前长度的所有子串，判断是否为回文串。遍历过程中，更新最长回文串

具体看代码：

public String longestPalindrome(String s) {
        int max = 1;    // 最长回文子串的长度
        int begin = 0;  // 最长回文子串的起始位置
        int n = s.length();
        boolean[][] dp = new boolean[n][n];
        // 初始化
        for (int i = 0; i < n; i++) {
            dp[i][i] = true;
        }
        // 遍历长度 2 至 n
        for (int len = 2; len <= n; len++) {
            // 遍历当前长度的所有子串
            // i 可以视为子串左边界
            for (int i = 0; i < n - len + 1; i++) {
                // j 可以视为子串右边界
                int j = i + len - 1;
                // 若边界处字符不等，一定不为回文串，跳过
                if (s.charAt(i) != s.charAt(j)) {
                    continue;
                }
                // 相等的情况
                // 若子串长度小于等于 3，一定为回文串
                if (j - i < 3) {
                    dp[i][j] = true;
                } else {    // 长度大于 3，是否是回文串与内部字符串相关
                    dp[i][j] = dp[i + 1][j - 1];
                }
                // 更新最长的回文串
                if (dp[i][j] && len > max) {
                    max = len;
                    begin = i;
                }
            }
        }
        return s.substring(begin, max + begin);
    }

动态规划 + 空间优化

上述方法是 O(n²)的时空复杂度，不过还有一种方法，可以把空间复杂度降为常量级

可知，每个回文串去除边界两个字符后还是回文串（或者空串），于是可以从字符串的单个字符和长度为 2 的子串开始向左右两个方向扩展

• 若当前左右边界字符相等，继续扩大边界，否则返回已经扩展的长度，也就是从本次扩展得到的回文串长度

这样就不用使用数组保存状态值，保存最长回文子串的起始位置即可

1. 遍历字符串
2. 求当前字符扩展可以得到的回文子串长度
3. 求当前字符与下一个字符拼成的字符串扩展可以得到的回文子串长度
4. 取两个扩展可以得到的最长回文串长度 len，若 len 大于已有的最长回文串长度，更新

具体看代码：

public String longestPalindrome(String s) {
        int n = s.length();
        int start = 0;
        int end = 0;
        // 遍历字符串
        for (int i = 0; i < n; i++) {
            // 当前位置扩展可以得到的回文子串长度
            int len1 = expand(s, i, i);
            int len2 = expand(s, i, i + 1);
            int len = Math.max(len1, len2);
            // 更新最长回文子串
            if (len > end - start) {
                // 更新起始位置
                start = i - (len - 1) / 2;
                // 更新终点位置
                end = i + len / 2 + 1;
            }
        }
        return s.substring(start, end);
    }

    // 扩展
    // begin 是扩展前的起始位置，end 是扩展前的终点位置
    public int expand(String s, int begin, int end) {
        int n = s.length();
        // 若未越界，且边界字符相等，继续扩展
        while (begin >= 0 && end < n && s.charAt(begin) == s.charAt(end)) {
            begin--;
            end++;
        }
        // 扩展得到的回文串长度
        return end - begin - 1;
    }