LeetCode之最长回文子串

最长回文子串

一、题目及要求

给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。

示例 1：
输入: “babad”
输出: “bab”
注意: “aba” 也是一个有效答案。

示例 2：
输入: “cbbd”
输出: “bb”

二、具体分析

（1）暴力解决法

• 暴力解决法是先将所有的子串求出，再从中筛选出是回文的子串。
• 具体实现步骤如下：

1. 创建空字符串，当做返回值；创建max变量用来存储子串长度的最大值；创建len存储字符串s的长度。

        //创建空字符串，当做返回值
        String s1 = "";
        //max用来存储子串长度的最大值
        int max = 0;
        // len存储字符串s的长度
        int len = s.length();

2. 使用双for循环和 substring() 方法来生成该字符串的所有子串。

       //使用subString方法生成子串
for (int i = 0; i < len; i++) {
            for (int j = i+1; j <= len; j++) {
                //flog用来存储生成的子串
                String flog = s.substring(i,j);
                    //筛选出，是回文，且长度最大的子串
                    if(EXE(flog) && flog.length() > max){
                        s1 = flog;
                        max = j-i;
                    }
                }
            }

3. 创建一个名为EXE的方法，该方法用来判断子串是否回文。

//创建方法，用来判断子串是否为回文
    private static boolean EXE (String s) {
        //存储该子串的长度，方便一会进行回文判断
        int len = s.length();
        for (int i = 0; i < len / 2; i++) {
            //判断是否回文
            if (s.charAt(i) != s.charAt(len - i - 1)) {
                return false;
            }
        }
        return true;
    }

4. 方法缺陷：在字符串过长时，需要花费大量时间，容易超时。

（2）中心位置算法

• 该方法的思想为，每个字符都可能为回文子串的中心位置，我们通过确定不同的中心位置，来判断子串是否为回文子串。
• 具体实现步骤如下：

1. 判断字符串是否为空，如果是空则返回空字符串，不需要进行其他判断。

 //判断字符串是否为空，如果是空则返回空字符串
        if(s==null||s.length()<0){
            return "";
        }

2. 定义两个标志start和end，让其分别指向字符串的首尾。这里是为了结合后面写的一个方法使用的，先创建出来，后面会继续介绍的。

//定义两个标志star和end，让其分别指向字符串的首尾
        int start = 0;
        int end = 0;

3. 创建一个名为EXE的方法来筛选确定了中心位置的回文子串。

//定义函数判断字符串是否回文
    public static int EXE (String s , int left , int right){
        int L = left, R = right;
        //使用while循环来判断是否为回文子串，判断的硬性条件为左指针大于等于0，右指针小于字符串的最大长度
        while (L >= 0 && R < s.length() && s.charAt(L) == s.charAt(R)) {
            //如果进入循环说明当前子串被左右指针指向的字符是相同的，接着移动左右指针，继续判断
            L--;
            R++;
        }
        //循环结束，说明回文判断结束，当前两个指针指向位置的中间部分为回文子串
        //将子串长度返回
        //并且将while循环中的l--和r++抵消，使其指向的位置仍旧为传参时指向的位置，求其长度
        return (R-1) - (L+1) + 1;
    }

4. 使用for循环确保将字符串的每个位置都当做中心位置去判断。（详情请看代码注释）

for (int i = 0; i < s.length(); i++) {
            //定义int类型的len1和len2是其值为函数EXE的返回值，存储的是回文子串的长度
            //字符串为奇数时，中心位置只有一个值，都是i
            int len1 = EXE(s,i,i);
            //字符串为偶数时，中心位置有两个值，为i和i+1
            int len2 = EXE(s,i,i+1);
            //判断最长的回文子串
            int max = Math.max(len1, len2);
            //确定回文字符串开始和结束的索引
            if (max > end - start) {
                start = i - (max-1) / 2;
                end = i + max / 2;
            }
        }

5. 通过 substring() 方法来生成回文子串。（注意：这里是通过上面的步骤将回文子串的首尾位置确定的，然后使用方法生成的；并不是 substring() 方法生成的就是回文子串）

//生成回文子串
        return s.substring(start, end + 1);

三、结果展示

1. 暴力解决法，会超时。
   
2. 中心位置算法，完美运行。
   

四、完整代码

（1）暴力解决代码

public class Test6 {
    public static void main(String[] args) {
        String s = "aa";
        String s1 = longestPalindrome(s);
        System.out.println(s1);
    }

    public static String longestPalindrome(String s) {
        //创建空字符串，当做返回值
        String s1 = "";
        //max用来存储子串长度的最大值
        int max = 0;
        // len存储字符串s的长度
        int len = s.length();
        //使用subString方法生成子串
        for (int i = 0; i < len; i++) {
            for (int j = i+1; j <= len; j++) {
                //flog用来存储生成的子串
                String flog = s.substring(i,j);
                    //筛选出，是回文，且长度最大的子串
                    if(EXE(flog) && flog.length() > max){
                        s1 = flog;
                        max = j-i;
                    }
                }
            }
        return s1;
    }

 //创建方法，用来判断子串是否为回文
    private static boolean EXE (String s) {
        //存储该子串的长度，方便一会进行回文判断
        int len = s.length();
        for (int i = 0; i < len / 2; i++) {
            //判断是否回文
            if (s.charAt(i) != s.charAt(len - i - 1)) {
                return false;
            }
        }
        return true;
    }
}

（2）中心位置代码

public class Test7 {
    public static void main(String[] args) {
        String s = "aa";
        String s1 = longestPalindrome(s);
        System.out.println(s1);
    }

    public static String longestPalindrome(String s) {
        //判断字符串是否为空，如果是空则返回空字符串
        if(s==null||s.length()<0){
            return "";
        }
        //定义两个标志star和end，让其分别指向字符串的首尾
        int start = 0;
        int end = 0;
        //定义for循环确定字符串的中心位置
        for (int i = 0; i < s.length(); i++) {
            //定义int类型的len1和len2是其值为函数EXE的返回值，存储的是回文子串的长度
            //字符串为奇数时，中心位置只有一个值，都是i
            int len1 = EXE(s,i,i);
            //字符串为偶数时，中心位置有两个值，为i和i+1
            int len2 = EXE(s,i,i+1);
            //判断最长的回文子串
            int max = Math.max(len1, len2);
            //确定回文字符串开始和结束的索引
            if (max > end - start) {
                start = i - (max-1) / 2;
                end = i + max / 2;
            }
        }
        //生成回文子串
        return s.substring(start, end + 1);
    }

    //定义函数判断字符串是否回文
    public static int EXE (String s , int left , int right){
        int L = left, R = right;
        //使用while循环来判断是否为回文子串，判断的硬性条件为左指针大于等于0，右指针小于字符串的最大长度
        while (L >= 0 && R < s.length() && s.charAt(L) == s.charAt(R)) {
            //如果进入循环说明当前子串被左右指针指向的字符是相同的，接着移动左右指针，继续判断
            L--;
            R++;
        }
        //循环结束，说明回文判断结束，当前两个指针指向位置的中间部分为回文子串
        //将子串长度返回
        //并且将while循环中的l--和r++抵消，使其指向的位置仍旧为传参时指向的位置，求其长度
        return (R-1) - (L+1) + 1;
    }

}

五、总结

• 在做这道题时，走了不少误区，最开始使用用ArrayList集合来做，发现回文判断会有问题，调试了很久都没成功，最后放弃了这个方法，转而直接去操作字符串，也就是上面的暴力解决法，但很可惜程序虽然解决了大部分问题，但是不够优化，在向LeetCode提交时，会超时。
• 接着我开始浏览各个大佬们的博客，发现使用较多的就是中心位置算法，于是我开始分析学习这种方法，并一步一步将他写出来，期间也还出现了不少问题，例如：小于等于没有写等于，导致判断少判断一步，得到的字符串不完整，还有奇数偶数的问题…
• 虽然过程有些坎坷(弄到昨晚三点才睡下)，不过结局是美好的，学习了一种新方法，希望这篇博客对大家有用，感谢！