Java LeetCode每日一题-从易到难带你领略算法的魅力（六）：最长回文子串

1.题目要求

• 给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。
• 回文的意思就是：正着读反着读都一样，是对称的

2.题目示例

• 示例 1：

输入: "babad"
输出: "bab"
注意: "aba" 也是一个有效答案。

• 示例 2：

输入: "cbbd"
输出: "bb"

3.提示

• How can we reuse a previously computed palindrome to compute a larger palindrome?
  我们如何重用一个先前计算的回文来计算一个更大的回文?
• If “aba” is a palindrome, is “xabax” and palindrome? Similarly is “xabay” a palindrome?
  如果“aba”是一个回文，“xabax”和回文吗?同样，“xabay”也是回文吗?
• Complexity based hint:
  If we use brute-force and check whether for every start and end position a substring is a palindrome we have O(n^2) start - end pairs and O(n) palindromic checks. Can we reduce the time for palindromic checks to O(1) by reusing some previous computation.
  基于复杂性的提示:
  如果我们使用蛮力检查每一个开始和结束位置的子字符串是否是一个回文，我们有O(n^2)开始-结束对和O(n)回文检查。我们能否通过重用以前的一些计算来将回文检查的时间减少到O(1) ?

4.解题

4.1 解题思路

1. 首先读题过后，我们能想到的是，就一个子串来说，如果它是一个回文串（长度大于2）,那么将它的首尾字母去除后，它依然是一个回文串。例如：“cbcbc”，在已知中间子串（“bcb”）是回文串的情况下，判断首尾字符串相等后，就可以确定“cbcbc”一定是回文串
2. 根据这样的思路，我们可以用动态规划的方法解决问题，我们用P（i，j）表示字符串s的第i到j个字母组成的串是否为回文串
3. P（i，j）等于true的话就可以判断子串Si~Sj是不是回文串，等于false的话包含两种可能性，第一个就是s[i，j]本身不是一个回文串，第二个就是i>j，此时s[i，j]本身不合法
4. 那么我们就可以得到动态规划的状态转移方程：
   P（i，j）=P（i+1，j-1）∧（Si==Sj）
5. 也就是说，只有s[i+1：j-1]是回文串，并且s的第i和j个字母相同时，s[i：j]才会是回文串
6. 上文的所有讨论是建立在子串长度大于2的前提之上的，我们还需要考虑边界条件，即子串长度为1或2的情况。对于长度为1的情况来说，它肯定是一个回文串，对于长度为2的情况来说，只要它们字母相同肯定是一个回文串。因此我们就可以给出动态规划的边界条件：P（i，i）=true和P（i，i+1）=（Si==Si+1）
7. 以上就已经考虑完所有的情况了，最终的答案为所有P（i，j）=true中j-i+1（回文子串长度）的最大值
8. 注意：在状态转移方程中，我们是从长度较短的字符串向长度较长的字符串进行转移的，因此一定要注意动态规划的循环顺序

4.2 业务代码

class Solution {
    public String longestPalindrome(String s) {
        int len = s.length();
        // 长度是1的情况，肯定是回文串
        if (len < 2){
            return s;
        }
		//最大回文子串长度
        int maxLen = 1;
        //最大回文子串，开始下标
        int begin  = 0;

        // 1. 状态定义
        // dp[i][j] 表示s[i...j] 是否是回文串
        // 2. 初始化
        boolean[][] dp = new boolean[len][len];
        for (int i = 0; i < len; i++) {
        	//字符串开始的第一个字符，肯定是回文子串
        	//而boolean默认的初始值是false，所以为了逻辑正确性设置为true
            dp[i][i] = true;
        }

        char[] chars = s.toCharArray();
        // 3. 状态转移
        // 注意：先填左下角
        // 填表规则：先一列一列的填写，再一行一行的填，保证左下方的单元格先进行计算
        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] = dp[i + 1][j - 1];
                    }
                }
                // 只要dp[i][j] == true 成立，表示s[i...j] 是否是回文串
                // 此时更新记录回文长度和起始位置
                if (dp[i][j] && j - i + 1 > maxLen){
                    maxLen = j - i + 1;
                    begin = i;
                }
            }
        }
        // 4. 返回值
        return s.substring(begin,begin + maxLen);
    }
}

4.3 运行结果

5.优化

5.1 优化思路

1. 其实这道题可以使用暴力枚举来做出来，就是枚举所有长度严格大于1的子串，然后判断子串是否是回文串（过于简单暴力就不演示了），这时回文串的枚举可以从两边开始也可以从中间开始，这时第二种思路就有了眉目。
2. 也就是中心扩散法，通过枚举所有可能子串的中心位置，然后从内向外依次判断是不是回文子串。
3. 这时就需要判断回文子串是奇数还是偶数，因为技术回文子串的中心位置只有一个字符，偶数回文子串中心有两个字符
4. 同时在枚举结束后，要记录子串相关变量

5.2 优化业务代码

class Solution {
    public String longestPalindrome(String s) {
        if (s == null || s.length() < 1){
            return "";
        }

        // 初始化最大回文子串的起点和终点
        int start = 0;
        int end   = 0;

        // 遍历每个位置，当做中心位
        for (int i = 0; i < s.length(); i++) {
            // 分别拿到奇数偶数的回文子串长度
            int len_odd = expandCenter(s,i,i);
            int len_even = expandCenter(s,i,i + 1);
            // 对比最大的长度
            int len = Math.max(len_odd,len_even);
            // 计算对应最大回文子串的起点和终点
            if (len > end - start){
                start = i - (len - 1)/2;
                end = i + len/2;
            }
        }
        // 注意：这里的end+1是因为 java自带的左闭右开的原因
        return s.substring(start,end + 1);
    }


    /**
     *
     * @param s             输入的字符串
     * @param left          起始的左边界
     * @param right         起始的右边界
     * @return              回文串的长度
     */
    private int expandCenter(String s,int left,int right){
        // left = right 的时候，此时回文中心是一个字符，回文串的长度是奇数
        // right = left + 1 的时候，此时回文中心是一个空隙，回文串的长度是偶数
        // 跳出循环的时候恰好满足 s.charAt(left) ！= s.charAt(right)
        while (left >= 0 && right < s.length() && s.charAt(left) == s.charAt(right)){
            left--;
            right++;
        }
        // 回文串的长度是right-left+1-2 = right - left - 1
        return right - left - 1;
    }
}

5.3 优化结果

6.总结

• 因为动态规划的时间空间复杂度都是O(n²)，而中心扩散法的空间复杂度只有O(1)，虽然时间复杂度还是是O(n²)，但是优化出来还是进不来不少。大家还有什么更好的方案欢迎在下面留言哟！