leetcode - 05 最长回文子串

传送门：https://leetcode-cn.com/problems/longest-palindromic-substring/solution/zui-chang-hui-wen-zi-chuan-by-leetcode-solution/

这道题的题目是在一个字符串s中寻找最长的回文子串，所谓回文子串就是正着读和反着读都一样的字符串，如 “aba”、“abxba"等等。
一个字符串中可能有多个最长的回文子串，如题目给的"babad”，那么"bab"和 "aba"都是正确答案。

解法

有很多种解法，这里先介绍两种：

• 暴力法
• 动态规划

暴力法

在本题中暴力法意味着穷举所有的字串，如"babad"，那么可穷举出"b",“ba”,“bab”,“baba”, “babad”, "a"等子串，我们判断每一个字串是否为回文子串，并记录其长度和起始下标，穷举所有可能后得到的就是最长的回文子串。

直接通过代码理解：

class Solution {
    public String longestPalindrome(String s) {
        if (a.length < 2) {
            return s;
        }
        
        char a[] = s.toCharArray();
        int maxLen = 1;
        int begin = 0;

        for (int i = 0; i < a.length - 1; i ++) {
            for (int j = i + 1; j < a.length; j++) {
                if (judge(a, i, j) && maxLen < j - i + 1) {
                    maxLen = j - i + 1;
                    begin = i;
                }
            }
        }

        return s.substring(begin, begin + maxLen);
    }

    private boolean judge(char[] arr, int left, int right) {
        while (left < right) {
            if (arr[left] != arr[right]) {
                return false;
            }
            left++;
            right--;
        }

        return true;
    }
}

说明：

• 代码开始就执行判断，如果字符串的长度小于2，即0或1，那么必然是回文子串，不必再继续判断。
• 接着将字符串转换为字符数组，因为每个字符至少是一个回文子串，所以设置回文子串最大长度初始值为maxLen=1，begin表示字串的起始下标。
• 开始循环，i从0到字符串长度-1，j从i+1到字符串的长度，对于每一个i，都有j从i+1开始直到字符串末尾，因此两层循环结束后能够遍历到所有的字串，那么只需要保证每次遍历子串时都可以判断其是否为回文子串，若不是则不做处理；若是，和目前为止最长的回文子串比较，看看哪个更长。
• 判断是否为回文子串，judge函数可以完成这项工作。传给它左右下标，左右同时向中间靠拢，一旦发现a[left]和a[right]不相等就返回false。
• 如果某个子串为回文串，则通过i和j即可获得它的长度。

动态规划

这种方法是基于这样一个事实：如果一个子串是回文串，那么在这个子串两端同时加上一个字符仍然为回文串，如"aba"是个回文串，那么两端同时加上"x" -> “xabax"仍然为回文串。反过来，如果有一字符串"x ??? x”，我们现在可以确定首和尾是x，那么这个字符串如果为回文串，则中间部分???必须也为回文串。

用i表示字符串的起始位置，就、表示结尾位置，那么整个字符串用S[i,j]表示，它为回文串等价于 S[i+1,j-1]也为回文串，这意味着S[i,j]需要用到S[i+1,j-1]的信息，而在二维数组中这对应着S[i,j]的左下角，可以用图来理解：

现有字符串**“babad”**:

0代表字符串第一个字符的下标，4是最后一个字符，用dp[i][j]表示字符i到字符j的字符串。那么dp[0][0]自然为true，dp[0][1]为false，因为’b’不等于’a’。dp[1][3]为true，因为dp[2][2]已经为true且’a’=‘a’，其他的同理。

class Solution {
    public String longestPalindrome(String s) {
        int len = s.length();
        char a[] = s.toCharArray();

        int maxLen = 1;
        int begin = 0;

        boolean dp[][] = new boolean[len][len];
        for (int i = 0; i < len; i ++) {
            dp[i][i] = true;
        } 

        for (int j = 1; j < len; j++) {
            for (int i = 0; i < j; i++) {
                if (a[i] != a[j]) {
                    dp[i][j] = false;
                }else {
                    if (j - i < 3) {
                        dp[i][j] = true;
                    }else {
                        dp[i][j] = dp[i+1][j-1];
                    }
                }
                if (dp[i][j] && j - i + 1 > maxLen) {
                    begin = i;
                    maxLen = j - i + 1;
                }
            }
        }

        return s.substring(begin, begin + maxLen);
    }
}

说明：

• 用dp[i][j]表示从字符i到字符j的字串是否为回文串，若是则为true，不是为false
• dp[i][i]=true，因为单个字符也算一个长度为1的回文串
• j从1开始循环，我们先搞定列，再搞定行，每进行一次外圈循环都会填完一列的表。dp[i][j]需要用到左下角元素的信息，举例来说，当j=4时，dp[1][4]需要dp[2][3]的信息，而dp[2][3]在j=3时就已经算出来了，因此这种做法是可行的。

动态规划(第二种解法)

在官方的题解中，使用了另一种动态规划，这里就直接copy了：

class Solution {
    public String longestPalindrome(String s) {
        int n = s.length();
        boolean[][] dp = new boolean[n][n];
        String ans = "";
        for (int l = 0; l < n; ++l) {
            for (int i = 0; i + l < n; ++i) {
                int j = i + l;
                if (l == 0) {
                    dp[i][j] = true;
                } else if (l == 1) {
                    dp[i][j] = (s.charAt(i) == s.charAt(j));
                } else {
                    dp[i][j] = (s.charAt(i) == s.charAt(j) && dp[i + 1][j - 1]);
                }
                if (dp[i][j] && l + 1 > ans.length()) {
                    ans = s.substring(i, i + l + 1);
                }
            }
        }
        return ans;
    }
}

说明：

• 在这里最外层的l表示字串的长度，l=0其实表示的是长度为1的字串。
• 为了理解内层i循环，我们举一个例子：当l为2（代表子串长度是3）而字符串长度为5时，i的遍历范围是（0，1，2），j的范围是i+l（这tm是L啊…我以为是数字1呢），即（2，3，4）.这样i和j一一对应正好是长度为3的字串。
• 若l为0，则dp[i][j]=true，意味着单个字符是长度为1的回文串
• 若l为1，则代表长度为2的子串，若s[i] == s[j]，那么dp[i][j]为true，否则为false。