最长回文子串

最长回文子串

给你一个字符串 s，找到 s 中最长的回文子串。

示例 1：

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

(1)暴力破解

class Solution {
    public String longestPalindrome(String s) {
        //使用暴力破解的方式进行求解
        //首先判断字符串的长度是否是在可以产生回文子串
        //如果该字符串的长度小于2 为 1 或  0  的话则最长回文子串就是本身
        int len = s.length();
        if(len < 2){
            return s;
        }
        //定义right定义的最大长度
        //left控制最小的
        int right = 1;
        int left = 0;
        char[] ArrayList = s.toCharArray();  //java 中类将字符串转换为字符串数组
        //枚举所有长度大于一的字符串

        for(int i = 0; i < len - 1; i++){
            for(int j = i + 1; j < len; j++) {
                if(j - i + 1 > right && huiwen(ArrayList, i, j)) {
                    right = j - i + 1;
                    left = i;

                }
            }
        }
        return s.substring(left, left + right);   //java 常用的类，将字符串转化为子字符串
    }

    //定义一个布尔函数判断数组是否为回文字符串
    //定义一个数组， 左指针右指针
        private boolean huiwen(char[] array, int left, int right){
            //如果满足left < right则证明数组中含有元素 
            while(left < right){
                //判断左下标对应的值 和右下标对应的值相等 则满足回文子串
                //如果想等满足的话left向右移动  right向左移动
                //依次遍历完left - right中的所有数组元素 如果均相等的话则返回true
                if(array[left] != array[right]){
                    return false;
                }
                left++;
                right--;
            }
            return true;
        }

}

(2)中心扩展算法

**利用和动态规划相似的想法，可以得出这个中心扩展的算法 **

需要注意的是，在这个过程中需要考虑好它的几种特殊情况 以及对于下标的把控，控制其不会下标越界

class Solution {
    public String longestPalindrome(String s) {
      //使用中心扩展的方法进行求解
      //先对特殊情况进行判断
      //如果字符串为空或者是字符串的长度小于1 直接返回一个空的字符串
      if(s == null || s.length() < 1) {
          return " ";
      }
      //定义两个控制变量， 一个控制开始，一个控制结束
      int left = 0, right = 0;
      //开始遍历数组中的元素
      for(int i = 0; i < s.length(); i++) {
          //这里要讨论两种情况  分别是字符串为奇数和偶数是的情况
          //奇数时最中间是一个字符 i
          int len1 = center(s, i, i);
          //偶数时最中间是两个字符 i 和 i-1
          int len2 = center(s, i, i + 1);
          //分别将得到的两个最长回文子串比较取出最大的值
          int len = Math.max(len1, len2);
          if(len > right - left) {
              //然后判断分别得出最长回文子串的最小下标和最大的下标
              //这个公式对于奇数个和偶数个都是用
              left = i - (len - 1) / 2;
              right = i + len / 2;
          }
      }
      return s.substring(left, right + 1);
        }

//创建一个方法用来体现中心扩展算法，判断从i开始的字符串向两边延伸从而得到最长回文字符串
    public int center(String s, int left, int right){
        //当满足left >= 0 && right < s.length() && s.charAt(left) == s.charAt(right条件时 可以判断为是回文子串
        while(left >= 0 && right < s.length() && s.charAt(left) == s.charAt(right)) {
            --left;
            ++right;
        }
        //返回回文字符串下标之间的距离
        return right -left - 1;
    }

}

(3) Manacher 算法

之后补充 点击爱寂寞的时光博客

(4)动态规划

使用动态规划算法，在暴力破解的基础上降低了时间复杂度

动态规划就是通过牺牲空间的做法来实现时间上的更优

class Solution {
    public String longestPalindrome(String s) {
        //使用动态规划方式进行求解
         int len = s.length();
         if(len < 2){
             return s;
         }

         //定义两个边界值
         int maxLen = 1;
         int begin = 0;

         //开始使用动态规划算法
         //dp[i][j]表示s[i ,j]是否是回文串

         boolean[][] dp = new boolean[len][len];
         char[] Array = 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(Array[i] != Array[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;
                 }
             }
         }
         return s.substring(begin, begin + maxLen);
        }
}

参考LeetCode