最长回文子串---力扣

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

示例 1：
输入：s = "babad"
输出："bab"
解释："aba" 同样是符合题意的答案。
示例 2：
输入：s = "cbbd"
输出："bb"
提示：
1 <= s.length <= 1000
s 仅由数字和英文字母组成

1. 暴力

/***
暴力：将所有的回文子串都找出来，记录返回最长的
 */


class Solution {
public boolean isPalindromic(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;
	}

// 暴力解法
public String longestPalindrome(String s) {
    String ans = "";
    int max = 0;
    int len = s.length();
    for (int i = 0; i < len; i++)
        for (int j = i + 1; j <= len; j++) {
            String test = s.substring(i, j);
            if (isPalindromic(test) && test.length() > max) {
                ans = s.substring(i, j);
                max = Math.max(max, ans.length());
            }
        }
    return ans;
}
}

2. 中心扩散

（1）从第 i 个字符开始，首先判断第 i 个字符的左边即第 i - 1 个与 第 i 个是否相同，如果相同，则 left --，接着向左右扩散，记录回文子串的个数 。
（2）如果左边与 第 i 个不相同，那判断第 i 个字符的右边即第 i + 1 个与 第 i 个是否相同，如果相同，则 right ++， 接着向左右扩散，记录回文子串的个数 。
（3）向左右扩散，判断 第 left 个字符与 第 right 个字符是否相同，如果相同，则回文子串个数++，反之与目前最长回文子串进行比较，更新最长回文子串的起始位置与长度。

/**
中心扩散
 */
class Solution {
    public String longestPalindrome(String s) {
        int len = s.length();
        int left = 0, right = 0;
        int maxStart = 0;
        int maxLen = 0;
        int count = 1;
        for (int i = 0; i < len; ++i) {
            left = i - 1;
            right = i + 1;
            //先判断左边的字符是否与i相等，即找到第i个的回文子串，如果没有就移动
            while(left >= 0 && s.charAt(left) == s.charAt(i)) {
                --left;
                // ++right;
                ++count;
            }
            //判断右边的字符是否与i相等，如果相等那么
            while(right < len && s.charAt(right) == s.charAt(i)) {
                // --left;
                ++right;
                ++count;
            }
            //左右扩散
            while(right < len && left >= 0 && s.charAt(left) == s.charAt(right)) {
                --left;
                ++right;
                count += 2;
            }
            if (maxLen < count) {
                maxLen = count;
                maxStart = left;
            }
            count = 1;
        }
        return s.substring(maxStart + 1, maxStart + maxLen + 1);
    }
}

3.动态规划

动态规划在中心扩散方法的基础上，减少重复的计算，用空间换时间。
用一个boolean dp[l][r]表示字符串从 i 到 j 这段是否为回文。试想如果 dp[l][r]=true，我们要判断 dp[l-1][r+1] 是否为回文。只需要判断字符串在(l-1)和(r+1)两个位置是否为相同的字符。
进入正题，动态规划关键是找到初始状态和状态转移方程。
初始状态，l=r 时，此时 dp[l][r]=true。
状态转移方程，dp[l][r]=true 并且(l-1)和(r+1)两个位置为相同的字符，此时 dp[l-1][r+1]=true。

class Solution {
    public String longestPalindrome(String s) {
        if (s == null || s.length() < 2)    
            return s;
        int maxStart = 0;
        int maxEnd = 0;
        int len = s.length();
        int maxLen = 1;  //最长回文串的长度

        boolean[][] dp = new boolean[len][len];

        for (int r = 1; r < len; r++) {
            for (int l = 0; l < r; l++) {
                if (s.charAt(l) == s.charAt(r) && (r - l <= 2 || dp[l + 1][r - 1])) {
                    dp[l][r] = true;
                    if (r - l + 1 > maxLen) {
                        maxLen = r - l + 1;
                        maxStart = l;
                        maxEnd = r;

                    }
                }
            }
        }
      return s.substring(maxStart, maxEnd + 1);
    }
}