LeetCode005——最长回文子串
我的LeetCode代码仓：https://github.com/617076674/LeetCode
原题链接：https://leetcode-cn.com/problems/longest-palindromic-substring/description/
题目描述：
知识点：动态规划
思路一：暴力解法（在LeetCode中提交会超时）
注意回文子串的定义，题目中的回文子串要求是连续的。
这是最直观的一个思路，遍历字符串s中的所有子串，判断该子串是否是回文，记录最长的回文子串即可。
这个方法的时间复杂度应该是O(n ^ 3)，其中n为字符串s的长度。解题过程中没有新开辟任何其他空间，所以空间复杂度显然是O(1)级别的。
JAVA代码：
public class Solution {
public String longestPalindrome(String s) {
String result = "";
for (int i = 0; i < s.length(); i++) {
for (int j = i; j < s.length(); j++) {
if(isPalidrome(s.substring(i, j + 1)) && (j + 1 - i) > result.length()) {
result = s.substring(i, j + 1);
}
}
}
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;
}
}思路二：思路一的改进
在思路一的第一重循环，我们的i不需要遍历到字符串s最末的位置，只需遍历到s.length() - result.length()位置即可，因为再往下找，就算找到了回文串，长度也肯定比之前找到的回文串要小。
在第二重循环，我们改为从后往前遍历，一旦找到了回文串，直接break跳出第二重循环进入下一轮的第一重循环。因为是从后往前遍历，接下来在第二重循环中找到的回文串长度肯定比第一次找到的要小。
这个思路的时间复杂度在最坏情况下显然是和思路一样的，是O(n ^ 3)级别的时间复杂度，但平均而言是比思路一要好的。空间复杂度显然也和思路一一样，是O(1)级别的。
JAVA代码：
public class Solution {
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解题报告：
思路三：中心向两边一起扩展
这个思路是参考某位博主的一个思路（给出链接：https://www.cnblogs.com/zhangboy/p/6505496.html）。可惜的是这位博主的思路虽然正确，但是他提供的Java代码却是错误的。这也提示我们参考某篇博文的时候一定要先运行一下他的代码，万一他的代码错了，我们或许可以选择不看这篇博文，因为他的思路很可能也是错误的。很庆幸至少那篇博文的思路是可行的。
思路一和思路二都是固定子串的一端去寻找子串的另一端，再来判断寻找到的子串是否是回文串。事实上我们完全可以换一种思路，对于字符串s中的每一个字符，我们假定它是回文串的中间字符，我们向该字符串的两边一起延伸，直到某一边不能延伸或者两边的字符不相等为止。
但要注意的是，回文串的中心分为两种情况，对于奇数回文串，其中心是某个字符，而对于偶数回文串，其中心是两个字符。另外，对于偶数回文串，我们可以让该字符和该字符的前一个字符组成回文串的中心，也可以让该字符和该字符的后一个字符组成回文串的中心，这又是两种情况。
这种方法实现的时间复杂度是O(n ^ 2)级别的，其中n为字符串s的长度。而空间复杂度，我们对于每一个s中的字符都需要保存三种情况得到的字符串，所以空间复杂度应该是O(n)级别的。
JAVA代码：
public class Solution {
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解题报告：
思路四：动态规划（在LeetCode中提交会超时）
就这道题而言，我觉得要第一时间想到用动态规划的方法来解决是很难的，但如果我们尝试了其他方法时间复杂度过高或者得不出答案的时候我们就可以考虑用动态规划的思路来解决问题。
动态规划的关键是找到合适的状态定义，并发现状态转移。
状态定义：f(x, y)表示区间[x, y]范围内所能取到的最长回文子串的长度。
状态转移：如果[x, y]范围的子串是回文子串，那么f(x, y) = y - x + 1。
如果[x, y]范围的子串不是回文子串，那么f(x, y) = max(f(x + 1, y), f(x, y - 1))。
由于对于每一个范围[x, y]我们都需要判断是否是回文子串，因此该思路的时间复杂度是O(n ^ 3)级别的。而对于空间复杂度，由于要记录一个n * n的二维数组，因此空间复杂度是O(n ^ 2)级别的。
因为要返回的是最长回文子串，而不是最长回文子串的长度。在求得[0, n - 1]范围内的最长回文子串的长度后，我们需要在二维数组maxLen中寻找长度等于该最长回文子串长度的子串，且寻找的顺序应该是(n - 2, n - 1) -> (n - 3, n - 2) -> (n - 3, n - 1) ->...，即从最小长度区间开始找起，找到的第一个就是最长回文子串。
JAVA代码：
public class Solution {
public String longestPalindrome(String s) {
if(s.length() < 2) {
return s;
}
int n = s.length();
int[][] maxLen = new int[n][n];
for (int i = 0; i < n; i++) {
maxLen[i][i] = 1;
}
for (int i = n - 2; i >= 0; i--) {
for (int j = i + 1; j < n; j++) {
if(isPalidrome(s.substring(i, j + 1))) {
maxLen[i][j] = j - i + 1;
}else {
maxLen[i][j] = Math.max(maxLen[i + 1][j], maxLen[i][j - 1]);
}
}
}
if(maxLen[0][n - 1] == 1) {
return s.substring(0, 1);
}
for (int i = n - 2; i >= 0; i--) {
for (int j = i + 1; j < n; j++) {
if(maxLen[i][j] == maxLen[0][n - 1]) {
return s.substring(i, j + 1);
}
}
}
return "";
}
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;
}
}
思路五：用一个二维数组来直接存储[x, y]范围的子串是否是回文子串
对于动态规划这一思路而言，思路四中时间复杂度的过高，一定是状态定义选择不当。我们换一种状态定义方法。
状态定义：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)级别的。
JAVA代码：
public class Solution {
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解题报告：
