这是一道在leetcode上看到的题目
一开始，我能想到的思路是蛮力法：
就遍历每个字符，然后对每个字符都尝试从1到n的长度，看有没有回文串，并记录以该字符起始的回文串的最大长度。
这个思路其实没有上手实现，因为和前面的那题求最大没有重复字符的substring的原始思路一样，时间复杂度是O(n^3)，是超时的。
然后是可以通过的方法：
两边扩展法：
抓住，回文串是轴对称的这个特点，即一个中心往两边探索，两边都是相等的。
实现上先要遍历每个字符，从0序号到s.length()-2序号，这里的遍历，是把它们作为中心。
然后每个中心，进行两个判断：
1.以这个字符为中心可能有字符个数为奇数的回文串，即以这个字符为中心，往两边扫描，两边的都相等。 扫描到不相等的地方，记下长度，就是以该字符为中心的最大的奇数回文串的长度。
2.以这个字符为中心可能有字符个数为偶数的回文串，即这个时候的对称中心为两个字符——像例如abccba，当遍历到c元素的时候，如果只是以它为中心，往两边扩散，会立刻发现b!=c，然后就判断不出是回文串了。
因此遍历的时候要对每个字符都进行两次判断，时间复杂度为O(n^2)
class Solution { /** *用的思路是 遍历每个元素，然后对每个元素进行两边扫描，扫描的同时可以判断是否回文串了，因为回文串必定是轴对称。 *对每个元素两边扫描的时候要分两种情况： 1.因为以一个元素为中心，可能构成奇数个字符的 回文串，也就是只关于那个元素对称； 2.又或者是构成偶数个字符的 回文串，这个时候就不止关于那个元素对称，还有它旁边的元素，例如abccba，当遍历到c元素的时候，如果只是以它为中心，往两边扩散，会立刻发现b!=c，然后就判断不出是回文串了。 因此遍历的时候要对每个字符都进行两次判断，时间复杂度为O(n^2) */ public String longestPalindrome(String s) { if(s.length() == 1)return s; //因为 如果s长度为1，进不了下面那个for循环…… int longestPalindromeLength = 0; String longestPalindromeStr = ""; for(int i = 0; i < s.length() - 1; i++) { //遍历每个字符，以每个字符为中心 进行判断以这个 字符为中心的所有字符串中有没 回文字符串，并求出最大的那个 int oddLongestLength = findLongestPalindrome(s, i); if(oddLongestLength > longestPalindromeLength) { longestPalindromeLength = oddLongestLength; longestPalindromeStr = s.substring(i - oddLongestLength/2, i + oddLongestLength/2 + 1);//注意这个subString后面那个index是不取的…… } int evenLongestLength = findLongestPalindrome(s, i, i + 1); if(evenLongestLength > longestPalindromeLength) { longestPalindromeLength = evenLongestLength; longestPalindromeStr = s.substring(i + 1 - evenLongestLength/2, i + evenLongestLength/2 + 1);//注意这个subString后面那个index是不取的…… } } return longestPalindromeStr; } /** * 以一个index为中心，找以它为中心的 所有 回文字符串 而且是 字符个数为奇数的回文字符串，因为偶数的话，中心应该是两个。 * @param s 字符串 * @param centerIndex 中心字符的index * @return 那个最长的 回文字符串的 长度 */ private int findLongestPalindrome(String s, int centerIndex) { int tempLongestLength = 0;//代表以这个centerIndex为中心的所有回文串中的 最大 for(int i = centerIndex, j = centerIndex; i >= 0 && j <= s.length() - 1; i--, j++) { if(s.charAt(i) == s.charAt(j)) { //说明出现了 一个回文串了 if( (j - i + 1) > tempLongestLength ) { tempLongestLength = j - i + 1; } } else { //如果不相等，说明不对称 直接break了 break; } } return tempLongestLength; } /** * 找以 这两个index为中心，个数为偶数的 所有 的回文字符串 * @param s 字符串 * @param leftCenterIndex 左边中心 * @param rightCenterIndex 右边中心 * @return 这两个中心拓展的最长 的 回文字符串的长度 */ private int findLongestPalindrome(String s, int leftCenterIndex, int rightCenterIndex) { int tempLongestLength = 0;//代表以这个centerIndex为中心的所有回文串中的 最大 for(int i =leftCenterIndex, j = rightCenterIndex; i >= 0 && j <= s.length() -1; i--, j++) { if(s.charAt(i) == s.charAt(j)) { //说明出现了 一个回文串了 if( (j - i + 1) > tempLongestLength ) { tempLongestLength = j - i + 1; } } else { //如果不相等，说明不对称 直接break了 break; } } return tempLongestLength; } }
动态规划法：
用一个二维数组来求解，dp[i][j]的值标识，字符串中从i到j是不是回文串。
dp[i][j]=1，我们只要想办法把二维数组填好后，找出j - 1 + 1最大的值，求出子串序列返回即可。
填二维数组的时候有几个情况：
1.单个字符的时候，也就是dp的对角线i==j的时候，肯定为1；
2.相邻字符的时候，也就是dp中j - i < 2的时候，只有两个相同才为1，即s.charAt(i)==s.charAt(j)时有dp[i][i + 1] = 1；
3.字符相隔大于2的时候，也就是j - 1 >= 2的时候，这个时候值为1，需要边缘两个值相等，也就是s.charAt(i)==s.charAt(j)；还有中间也是回文串——也即dp[i+1][j-1] == 1
具体代码实现的话，分三轮遍历来
首先有个二维数组，然后：
1.第一轮遍历，单个字符是回文串，也就是dp[i][i] = 1；
2.第二轮遍历，相邻字符是不是回文串呢？遍历看相邻字符是不是相等的，即s[i]和s[i + 1]相等的话则有dp[i][i + 1] = 1，即j - 1 == 1的情况；
3.第三轮遍历，真正的动态规划，刚刚把数组dp中对角线上的还有dp[i][j]i和j间隔为1的也就j - 1 < 2的情况的空都填了，现在要做的是利用前面数组的结果，填dp数组中j - i >= 2的格子。第三轮遍历是个二重循环，j - i >=2时，进行遍历，然逐渐增大j和i的距离。只有s[i] == s[j]，且dp[i + 1][j - 1]为1两者都成立的情况下，dp[i][j] = 1。
算法Time:O(n^2), Space:O(n^2)。
代码：（引用自——https://www.cnblogs.com/clnchanpin/p/6880322.html）
public String longestPalindrome(String s) { if (s == null) return null; if(s.length() <=1) return s; int maxLen = 0; String longestStr = null; int length = s.length(); int[][] table = new int[length][length]; //every single letter is palindrome for (int i = 0; i < length; i++) { table[i][i] = 1; longestStr = s.charAt(i) + ""; //此时 最大的 回文串就是 单个字咯 maxLen = 1;//最大回文串长度就为1咯 } //two consecutive same letters are palindrome for (int i = 0; i <= length - 2; i++) { if (s.charAt(i) == s.charAt(i + 1)){//相隔的两个字相等 table[i][i + 1] = 1; longestStr = s.substring(i, i + 2); maxLen = 2;//两个相等的字符串嘛 } } //condition for calculate whole table //前面对于单个字也就是二维数组中对角线上的情况还有 间隔相等的情况 也就是j - i = 1的情况都处理了 //这里是 对其他需要 借助动态规划也就是之前数组的结果来操作的情况 也就是 j - 1 >=2的情况 for (int len = 3; len <= length; len++) { /*第一层循环 是以长度为基准的，因为这里处理的是j - i >=2的情况嘛，也就是比如abc，a和c这样的情况，也就是子串长度3以上的情况，所以第一层循环就描述这个，从3开始慢慢加
*直到table[0][length - 1]填好就可以有结果了
*/ for (int i = 0; i < length - len + 1; i++) { //这个条件是 因为len = j - 1 + 1，然后又有j < length得来的 int j = len + i - 1;//len = j - 1 + 1 if(s.charAt(i) == s.charAt(j) && table[i + 1][j - 1] == 1) { table[i][j] = 1; if(len > maxLen) { longestStr = s.substring(i, j + 1); } } else { table[i][j] = 0; } } } return longestStr; }
还有个很出名的Manacher 算法，时间复杂度为O(n)，具体的一时半会没看懂，以后需要再找资料吧~