LeetCode题解——最长回文子串
我的LeetCode代码集：https://github.com/cnamep001/LeetCode
原题链接：https://leetcode-cn.com/problems/longest-palindromic-substring/description/
题目描述：
思路一：用二维数组
对于动态规划这一思路而言，思路四中时间复杂度的过高，一定是状态定义选择不当。我们换一种状态定义方法。
状态定义：f(x, y)表示区间[x, y]范围的子串是否是回文子串。
状态转移：如果[x + 1, y - 1]范围的子串是回文子串且s.charAt(x) == s.charAt(y)，那么f(x, y)范围的子串就是回文子串。否则，不是回文子串。
在求得这个二维数组后，我们只需要找到该二维数组中y - x差值最大且值为true的元素即找到了我们所要求的回文子串。那这怎么找呢？我们从这个二维数组的右上角按着(0 , n - 1) -> (0, n - 2) -> (1, n - 1) -> (0, n - 3) -> (1, n - 2) -> (2, n - 1)……的顺序一步步遍历，找到第一个为true的元素即可。
显然，该方法只有2重循环，时间复杂度是O(n ^ 2)级别的。而对于空间复杂度，和思路四一样，也是O(n ^ 2)级别的。
实现代码:
package com.m.longest_palindromic_substring.solution1;
public class Solution1 {
public String longestPalindrome(String s) {
if (s.length() < 2) {
return s;
}
if (s.length() == 2) {
if (s.charAt(0) == s.charAt(1)) {
return s;
} else {
return s.substring(0, 1);
}
}
int n = s.length();
boolean[][] isPalindrome = new boolean[n][n];
for (int i = 0; i < n; i++) {
isPalindrome[i][i] = true;
}
for (int i = n - 2; i >= 0; i--) {
for (int j = i + 1; j < n; j++) {
if (s.charAt(i) == s.charAt(j) && (isPalindrome[i + 1][j - 1] || j - i <= 2)) {
isPalindrome[i][j] = true;
}
}
}
String result = s.substring(0, 1);
for (int k = -n + 1; k <= -1; k++) {
for (int i = 0; i < n - 1; i++) {
if (i - k < n && isPalindrome[i][i - k]) {
return s.substring(i, i - k + 1);
}
}
}
return result;
}
}
LeetCode解题报告：
思路二：中心向两边一起扩展
这个思路是参考某位博主的一个思路（给出链接：https://www.cnblogs.com/zhangboy/p/6505496.html）
可惜的是这位博主的思路虽然正确，但是他提供的Java代码却是错误的。这也提示我们参考某篇博文的时候一定要先运行一下他的代码，万一他的代码错了，我们或许可以选择不看这篇博文，因为他的思路很可能也是错误的。很庆幸至少那篇博文的思路是可行的。
思路一和思路二都是固定子串的一端去寻找子串的另一端，再来判断寻找到的子串是否是回文串。事实上我们完全可以换一种思路，对于字符串s中的每一个字符，我们假定它是回文串的中间字符，我们向该字符串的两边一起延伸，直到某一边不能延伸或者两边的字符不相等为止。
但要注意的是，回文串的中心分为两种情况，对于奇数回文串，其中心是某个字符，而对于偶数回文串，其中心是两个字符。另外，对于偶数回文串，我们可以让该字符和该字符的前一个字符组成回文串的中心，也可以让该字符和该字符的后一个字符组成回文串的中心，这又是两种情况。
这种方法实现的时间复杂度是O(n ^ 2)级别的，其中n为字符串s的长度。而空间复杂度，我们对于每一个s中的字符都需要保存三种情况得到的字符串，所以空间复杂度应该是O(n)级别的。
实现代码:
package com.m.longest_palindromic_substring.solution2;
public class Solution2 {
public String longestPalindrome(String s) {
if (s.length() < 2) {
return s;
}
if (s.length() == 2) {
if (s.charAt(0) == s.charAt(1)) {
return s;
} else {
return s.substring(0, 1);
}
}
String result = "";
for (int i = 1; i < s.length() - 1; i++) {
String odd = maxOddPalindrome(s, i - 1, i + 1);
String even1 = maxEvenPalindrome(s, i - 1, i);
String even2 = maxEvenPalindrome(s, i, i + 1);
if (odd.length() > even1.length()) {
if (even2.length() > odd.length() && even2.length() > result.length()) {
result = even2;
} else if (odd.length() > result.length()) {
result = odd;
}
} else {
if (even2.length() > even1.length() && even2.length() > result.length()) {
result = even2;
} else if (even1.length() > result.length()) {
result = even1;
}
}
}
return result;
}
private String maxOddPalindrome(String s, int k, int j) {
while (k >= 0 && j < s.length() && s.charAt(k) == s.charAt(j)) {
k--;
j++;
}
return s.substring(k + 1, j);
}
private String maxEvenPalindrome(String s, int k, int j) {
while (k >= 0 && j < s.length() && s.charAt(k) == s.charAt(j)) {
k--;
j++;
}
return s.substring(k + 1, j);
}
}
LeetCode解题报告：
思路三：循环
第一重循环，我们的i不需要遍历到字符串s最末的位置，只需遍历到s.length() - result.length()位置即可，因为再往下找，就算找到了回文串，长度也肯定比之前找到的回文串要小。
在第二重循环，我们改为从后往前遍历，一旦找到了回文串，直接break跳出第二重循环进入下一轮的第一重循环。因为是从后往前遍历，接下来在第二重循环中找到的回文串长度肯定比第一次找到的要小。
这个思路的时间复杂度在最坏情况下显然是和思路一样的，是O(n ^ 3)级别的时间复杂度，但平均而言是比思路一要好的。空间复杂度显然也和思路一一样，是O(1)级别的。
实现代码:
package com.m.longest_palindromic_substring.solution3;
public class Solution3 {
public String longestPalindrome(String s) {
String result = "";
for (int i = 0; i < s.length() - result.length(); i++) {
for (int j = s.length() - 1; j >= i; j--) {
if(isPalidrome(s.substring(i, j + 1)) && (j + 1 - i) > result.length()) {
result = s.substring(i, j + 1);
break;
}
}
}
return result;
}
private boolean isPalidrome(String s) {
for (int i = 0; i < s.length() / 2; i++) {
if(s.charAt(i) != s.charAt(s.length() - i - 1)) {
return false;
}
}
return true;
}
}
LeetCode解题报告：
