算法之路-最长回文子串

---

前言

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

一、暴力破解

算法描述：

找到所有子串，判定是否是回文串，保存最长长度的回文串。

代码实现：

class Solution {
        public static String longestPalindrome(String s) {
        //存储最长子串
        String str = "";
        //存储最长长度
        int longest = 0;
        for (int i = 0; i < s.length(); i++) {
            for (int j = i+1; j < s.length() + 1; j++) {
                String str1 = s.substring(i, j);
                if (isPalindromes(str1) && str1.length()>longest) {
                    str = str1;
                    longest= str.length();
                }
            }
        }
        return str;
    }
 
    public static boolean isPalindromes(String str) {
        if (str.length() == 1) {
            return true;
        }
        for (int i = 0; i < str.length() / 2; i++) {
            if (str.charAt(i) != str.charAt(str.length() - 1 - i)) {
                return false;
            }
        }
        return true;
    }
}

暴力破解能跑通就行，慢慢优化。

二、暴力循环优化版

算法描述：

把s字符串变成chars字符数组，就不用每次都调用substring截取字符串。
第二次循环 j = i + maxLen开始循环就可以了，因为目前最大长度为maxLen，子串小于这个长度就不可能是 最长回文串。
substring() 方法 左闭右开。第二个参数除了用截取最后一个字符下标+1，也可以用开始字符下标+长度。
优化后可以通过力扣。暴力循环是最容易想到的，但也是性能相对较差的一种。

代码实现：

class Solution {

 public static String longestPalindrome(String s) {
        int len = s.length();
        if (len < 2) {
            return s;
        }
        //最大长度
        int maxLen = 0;
        //开始的下标
        int begin = 0;
        //存储s字符数组，就可以不用每次截取字符串比较了。
        char[] chars = s.toCharArray();
        for (int i = 0; i < len - 1; i++) {
            //子串长度比maxLen小，那么他不可能是最长回文子串了。
            for (int j = i + maxLen; j < len; j++) {
                if (isPalindromes(chars,i,j) && j - i + 1 > maxLen){
                    //重新记录最大长度和开始下标
                    maxLen = j-i+1;
                    begin = i;
                }
            }
        }
        //这种第二个参数为开始下标+长度 ，比 结束下标+1 更简单更容易。
        return s.substring(begin,begin+maxLen);
    }
 
    //chars[left]至chars[right]是否是回文串，包括左右下标
    public static boolean isPalindromes(char[] chars, int left, int right) {
        while (left <= right) {
            //不是回文串
            if (chars[left] != chars[right]) {
                return false;
            }
            left++;
            right--;
        }
        return true;
    }
}

三、动态规划

算法描述：

动态规划主要是要找到 动态转移方程 和 边界。
dp[ i ][ j ]表示字符串第 i 个字符到 第 j 个字符 是否是回文串，左闭右闭。
一个回文串，他的首尾加上同样的字符后他依旧是回文串。例如回文串bab，首位加上同样字符a，即ababa，依旧是回文串。
我们可以得出一个状态转移方程： dp[ i ][ j ] = (s[i] == s[j]) and dp[i + 1][j - 1] 。即dp[i + 1][j - 1]是回文串且s[i] 与 s[j]字符相同，那么dp[ i ][ j ] 就是回文串。
动态规划都可以看做填表格，这题表格为：
因为 i <= j，所以这张表我们只需要填右半部分。
边界：因为状态转移方程 dp[ i ][ j ] = (s[i] == s[j]) and dp[i + 1][j - 1] ，所以 i + 1和j - 1 也应该符合 i <= j的条件，代入 i + 1 <= j - 1 ，得 j - i >=2。那么 j - i < 2，即为边界也就是我们不能用状态转移方程求出来。
j - i < 2，意味着dp[ i ][ j ]，除去s[i] 、s[j]后，dp[ i ][ j ]只剩下1个或0个元素（一个字符或空字符串）。那么只要s[i] == s[j]，dp[ i ][ j ]一定是回文串。（当只有一个字符或空字符串头尾再加上相同字符他一定是回文串）。
为了增加性能，我们可以初始化dp[ i ][ i ]为true，即只有一个字符是一定是回文串。同时 dp[ i ][ j ] = (s[i] == s[j]) and dp[i + 1][j - 1]，意味着若s[i] == s[j] ，dp[ i ][ j ]是否是回文串要参考dp[i + 1][j - 1] （j - i < 2不需要直接为true），dp[i + 1][j - 1]在dp[ i ][ j ]的左下方，我们可以竖着填即 j 是大循环，i 为小循环。这样我们每次都可以参考左下方的值。

代码实现：

class Solution {
 public static String longestPalindrome(String s) {
        int len = s.length();
        if (len < 2) {
            return s;
        }
        //最大长度
        int maxLen = 1;
        int begin = 0;
        //存储是否是回文串
        boolean[][] dp = new boolean[len][len];
        char[] chars = s.toCharArray();
        //单个字符一定是回文
        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 (chars[i] != chars[j]) {
                    dp[i][j] = false;
                } else {
                    //长度为2或3是，肯定是回文。即除去chars[i]和 chars[j]后，只要1个或0个字符。防止出现例如 i=2 j=3情况下 查看dp[3][2]。
                    if (j - i < 2) {
                        dp[i][j] = true;
                    } else {
                        //排除头尾元素后，是否是回文串
                        dp[i][j] = dp[i + 1][j - 1];
                    }
                }
                if (dp[i][j] && j - i + 1 > maxLen) {
                    maxLen = j - i + 1;
                    begin = i;
                }
            }
        }
        return s.substring(begin, maxLen + begin);
    }
}

示例：abcba

初始化：单个字符一定是回文串。
j从i开始循环。
j = 1时，chars[i] != chars[j]，即头尾字符不相同一定不是回文串，返回false。
j = 2时， i=0和i=1 ，chars[i] != chars[j]，均为false。

j=3时，i=0 chars[i] != chars[j]，所以false。
i=1时，dp[i][j] = dp[i + 1][j - 1]成立，参考左下dp[2][2]，是回文串。更新最大长度为3和开始下标1。
i=2时 ，chars[i] != chars[j]，为flase。

j=4时，i=0时 chars[i] == chars[j]，j - i >=2 ,所以参考左下dp[1][3]，dp[1][3]为true则dp[0][4]也为true，更新最大长度为5，开始下标为0。
剩余 i 都是 chars[i] != chars[j]，所以都为false。

动态规划这种思路特别重要，要学会。第一次学习使用动态规划一步一步像解方程一样列出来，理解着解起来。

四、中心扩展

算法描述：

假设每个字符都是回文串最中心的字符，从中心字符向两边扩展，若左右字符不同则他就不会是回文串。
因为回文串长度为奇偶情况不同分辨讨论，每个字符都可能是奇偶长度回文串的中心。当奇数时，只需 i 向两边扩展就可以了。当偶数时，先判断 i ==i+1 字符是否一样，一样则向两边扩展，否则他就不可能是回文串了。
为了方法通用合并被为一种，奇数传入参数 i 和 i，偶数传入参数 i 和 i+1。
这种方法需要左右指针，记录左右字符，方便向两边扩展。

代码实现：

class Solution {
 public static String longestPalindrome(String s) {
        int len = s.length();
        if (len < 2) {
            return s;
        }
        char[] chars = s.toCharArray();
        //最大长度
        int maxLen = 0;
        int begin = 0;
        //char[0] chars[len-1] 时是第一个和最后一个元素,无法左扩展和无法右扩展，排除这俩个元素。
        for (int i = 0; i < len - 1; i++) {
            //回文子串长度为奇数，初始子串为一个字符charAt(i)
            int oddLen = expandAroundCenter(chars, i, i);
            //回文子串长度为偶数，初始子串为charAt(i)和charAt(i+1)，i<len-1，i+1不会下标越界
            int evenLen = expandAroundCenter(chars, i, i + 1);
            //取奇偶情况下的当前最长回文子串
            int curMaxLen = Math.max(oddLen, evenLen);
            //比当前存储最长回文子串长，重新存储
            if (curMaxLen > maxLen) {
                // 当回文子串为偶数，一定是i右边多一个字符。
                // 所以左边长度要减1
                // 回文字符串奇数时 int/2取整  -1也不影响结果
                maxLen = curMaxLen;
                begin = i - (maxLen - 1) / 2;
            }
            //优化
            if((len-i-2)*2+1 <maxLen){
                return s.substring(begin, begin + maxLen);
            }
        }
        return s.substring(begin, begin + maxLen);
    }
 
    //计算下标为i时，最长回文子串的长度
    public static int expandAroundCenter(char[] chars, int left, int right) {
        while (left >= 0 && right < chars.length && chars[left] == chars[right]) {
            //是回文串，向外扩展
                left--;
                right++;
        }
        return right - left - 1;
    }
}

字符串最后一个字符，无法向两边扩展，所以排除这个元素，i只到 len-2
示例：ababa

i = 0时，
奇数情况：从i=0，从字符a开始扩展，扩展到 left = -1 、right =1 ，不满足循环条件，返回1-（-1）-1 =1 ，回文子串为a。
偶数情况： 从i=0，i+1=1 开始扩展。因为不满足chars[left] == chars[right] ，没有回文子串，返回 1-0-1 = 0。
目前最大长度为奇数情况下 1。记录最长长度 1 和开始下标 0。

i = 1时，
奇数情况：从i=1，从字符b开始扩展，扩展到 left = -1 、right =3 ，不满足循环条件，返回3-（-1）-1 =3 ，回文子串为aba。
偶数情况： 从i=1，i+1=2 开始扩展。因为不满足chars[left] == chars[right] ，没有回文子串，返回 2-1-1 = 0。
目前最大长度为奇数情况下 3。记录最长长度 3 和开始下标 0。

i = 2时，
奇数情况：从i=2，从字符a开始扩展，扩展到 left = -1 、right =5 ，不满足循环条件，返回5-（-1）-1 =5 ，回文子串为ababa。
偶数情况： 从i=2，i+1=3 开始扩展。因为不满足chars[left] == chars[right] ，没有回文子串，返回 3-2-1 = 0。
目前最大长度为奇数情况下 5。记录最长长度 5 和开始下标 0。

i = 3时，
奇数情况：从i=3，从字符b开始扩展，扩展到 left = 1 、right =5 ，不满足循环条件，返回5- 1-1 =3 ，回文子串为aba。
偶数情况： 从i=3，i+1=4 开始扩展。因为不满足chars[left] == chars[right] ，没有回文子串，返回 4-3-1 = 0。
目前最大长度为奇数情况下 3，小于最长长度5。所以最长长度 5为 和开始下标 0。
再写过程时发现，其实这个例子中，i=3是可以不用循环了。即使i=3处的字符是回文中心，那么他到s的最后一个字符，回文长度也只能是3，他还是小于5。如示例ababa，i=2处 a是回文中心，他长度为5，即使i=3处的b是回文中心，他的子串结尾也只能到字符串s的结尾，长度为3（len-3+1）。他依旧比 i=2处 a是回文中心长度小，所以他就不用循环。

即当 i+1 为回文中心，结尾字符为s字符串的最后一个字符，他的长度为 （len-1-（i+1））*2 +1 。
（len-1-（i+1））*2 +1 < maxlLen 时 i+1以及后面都不用循环了，已经找到最长的回文串了。
这里默认i+1 是奇数回文中心，因为是奇数回文中心，比i+1是偶数回文中心长。

五、Manacher 算法

> 如何找到字符串中的最长回文子串？

算法描述：

我看csdn大佬文章学习的Manacher 算法，感觉比力扣官方写的更加详细也有相应的例子。
这边文章写的已经很详细，明白原理可以自己动手跑一遍。
我感觉Manacher算法，就是用已知最长的回文串，根据回文串特性减少运算。
简单说下要：
字符串 cabadabae
最长回文子串 c | abadaba | e
两种情况，判断看是否需要中心扩展
i = 5时，根据回文串特性，关于 i=4 对称中心，i = 5 和 i = 3一样的回文串，半径为 0。5+0+1 看加上半径后的下一位是否在边界内。在边界范围内，不需要中心扩展。
i = 6时，根据回文串特性，关于 i=4 对称中心，i = 6 和 i = 2一样的回文串，回文子串为aba，半径1。6+1+1 = 8，而i = 8 并不在边界范围内，我们无法根据已知最长回文子串abadaba得到i=8字符是什么，所以需要得到回文子串aba后中心扩展，查看i = 8与 i = 4是否相等，才能判断当前子串是否是回文子串。
对文章的代码做了些细节的改变和注释加了些内容
这里先给出奇数长度字符串的代码，用这个代码跑一边更容易理解，然后再加上#，把所用字符串都处理成奇数长度。

代码实现：

class Solution {
 public static String longestPalindrome(String s) {
        // 处理后的字串长度
        int len = s.length();
        // 右边界
        int rightSide = 0;
        // 右边界对应的回文串中心
        int rightSideCenter = 0;
        // 保存以每个字符为中心的回文半径
        int[] halfLenArr = new int[len];
        // 记录最长回文中心
        int center = 0;
        // 记录最长回文半径
        int longestHalf = 0;
        for (int i = 0; i < len; i++) {
            // 是否需要中心扩展
            boolean needCalc = true;
            // 如果在右边界的覆盖之内，可以用回文特性
            if (rightSide > i) {
                // 计算相对rightSideCenter的对称位置
                int leftCenter = rightSideCenter - (i - rightSideCenter);
                // 根据回文性质得到的结论
                halfLenArr[i] = halfLenArr[leftCenter];
                // 如果超过了右边界，进行调整
                if (i + halfLenArr[i] > rightSide) {
                    halfLenArr[i] = rightSide - i;
                }
                // 如果根据已知条件计算得出的最长回文小于右边界，则不需要扩展了。得到的回文再边界范围内
                if (i + halfLenArr[leftCenter] < rightSide) {
                    // 直接推出结论
                    needCalc = false;
                }
            }
            // 中心扩展
            if (needCalc) {
                while (i - 1 - halfLenArr[i] >= 0 && i + 1 + halfLenArr[i] < len) {
                    if (s.charAt(i + halfLenArr[i] + 1) == s.charAt(i - halfLenArr[i] - 1)) {
                        halfLenArr[i]++;
                    } else {
                        break;
                    }
                }
                // 更新右边界及中心
                rightSide = i + halfLenArr[i];
                rightSideCenter = i;
                // 记录最长回文串
                if (halfLenArr[i] > longestHalf) {
                    center = i;
                    longestHalf = halfLenArr[i];
                }
            }
        }
        String substring = s.substring(center - longestHalf, center + longestHalf + 1);
        return substring;
    }
}

加#处理后的代码：

代码实现：

class Solution {
 public static String longestPalindrome(String s) {
      // 先预处理字符串
        String str = preHandleString(s);
        // 处理后的字串长度
        int len = str.length();
        // 右边界
        int rightSide = 0;
        // 右边界对应的回文串中心
        int rightSideCenter = 0;
        // 保存以每个字符为中心的回文半径
        int[] halfLenArr = new int[len];
        // 记录最长回文中心
        int center = 0;
        // 记录最长回文半径
        int longestHalf = 0;
        for (int i = 0; i < len; i++) {
            // 是否需要中心扩展
            boolean needCalc = true;
            // 如果在右边界的覆盖之内，可以用回文特性
            if (rightSide > i) {
                // 计算相对rightSideCenter的对称位置
                int leftCenter = rightSideCenter - (i - rightSideCenter);
                // 根据回文性质得到的结论
                halfLenArr[i] = halfLenArr[leftCenter];
                // 如果超过了右边界，进行调整
                if (i + halfLenArr[i] > rightSide) {
                    halfLenArr[i] = rightSide - i;
                }
                // 如果根据已知条件计算得出的最长回文小于右边界，则不需要扩展了。得到的回文再边界范围内
                if (i + halfLenArr[leftCenter] < rightSide) {
                    // 直接推出结论
                    needCalc = false;
                }
            }
            // 中心扩展
            if (needCalc) {
                while (i - 1 - halfLenArr[i] >= 0 && i + 1 + halfLenArr[i] < len) {
                    if (str.charAt(i + halfLenArr[i] + 1) == str.charAt(i - halfLenArr[i] - 1)) {
                        halfLenArr[i]++;
                    } else {
                        break;
                    }
                }
                // 更新右边界及中心
                rightSide = i + halfLenArr[i];
                rightSideCenter = i;
                // 记录最长回文串
                if (halfLenArr[i] > longestHalf) {
                    center = i;
                    longestHalf = halfLenArr[i];
                }
            }
        }
        // 去掉之前添加的#
        StringBuffer sb = new StringBuffer();
        for(int i = center - longestHalf + 1; i <= center + longestHalf; i += 2) {
            sb.append(str.charAt(i));
        }
        return sb.toString();

    }

    public static String preHandleString(String s) {
        StringBuffer sb = new StringBuffer();
        int len = s.length();
        sb.append('#');
        for (int i = 0; i < len; i++) {
            sb.append(s.charAt(i));
            sb.append('#');
        }
        return sb.toString();
    }
}

自己看明白原理，看代码却看不懂，跑了一遍豁然开朗，自己实践中也遇到不少的坑，慢慢的看着补知识吧。

总结

动态规划的思想（要找到状态转移方程和边界条件）
找回文串常用方法中心扩展
substring()，不要总参与循环，可以把字符串变成字符数组，左右指针参与循环。找到结果后在用substring()取得子串。
Manacher(马拉车)，找最长回文串的最优方法，时间复杂度只为O(n)，局限这种思路用于找到最长的回文子串，不像动态规划、中心扩展可以用在其他题目中。

新的算法知识，让菜鸡的我更加怀疑人生。最近的工作很忙，才入职新的公司，低代码的前端让我后端小菜鸡弄，痛苦。尽管痛苦但我依然会保证每月至少有更新，谢谢各位大佬的浏览，顺手帮菜鸡点个赞吧。