题目描述
leetcode地址
给定一个字符串 ，找到其最长的回文子串，回文的意思是，将字符翻转后仍为原字符。
例：输入abcbd，输出：bcb
/**
* @param {string} s
* @return {string}
*/
var longestPalindrome = function(s) {
// Your code
}
方法一：中心扩散法
分析：回文字符的特点是以某个字符为对称点，其两侧对应位置的字符相同，要注意如果中心字符串是偶串，则需要特殊处理，不能直接往两边扩散，比如abccbd，若以c为中心往两边扩散没有考虑其是偶串，就得不到正确结果。
图示：
/**
* @param {string} s
* @return {string}
*/
var longestPalindrome = function(s) {
let size = s.length
if(size <= 1) return s
if(size === 2) return s[0] === s[1] ? s : s[0]
let palindromicStr = ''
for(let i = 1; i < size-1; i++) {
let left = i-1, right = i+1;
let temp = s[i]
while(left >= 0 && s[left] === s[i]) {
temp += s[left]
left--
}
while(right < size && s[right] === s[i]) {
temp += s[right]
right++
}
while(left >= 0 && right < size) {
if(s[left] !== s[right]) break;
temp = s[left] + temp + s[right]
left--
right++
}
if(temp.length > palindromicStr.length) {
palindromicStr = temp
}
}
return palindromicStr
};
时间复杂度：O(n^2)
空间复杂度：O(n)
方法二：扩展字符的中心扩散法
上面的代码中，有两个额外的while循环，它们处理的是当中心字符是偶串的场景。
while(left >= 0 && s[left] === s[i]) {
temp += s[left]
left--
}
while(right < size && s[right] === s[i]) {
temp += s[right]
right++
}
如果在每个字符间都插入一个特殊字符，就能处理所有的场景，如图：
如果中心字符是奇数，那么中心元素就是它本身，如果中心字符是偶串，那么中心元素是插入的特殊符号。不管是什么，总之都不用考虑中心元素是偶串还是奇串了。
代码实现：
/**
* @param {string} s
* @return {string}
*/
var longestPalindrome = function(s) {
let size = s.length
if(size <= 1) return s
let str = '#'
for(let i = 0; i < size; i++) {
str += s[i] + '#'
}
size = str.length
let min = 0, max = 0
for(let i = 1; i < size-1; i++) {
let left = i-1, right = i+1;
while(left >= 0 && right < size) {
if(str[left] !== str[right]) break;
left--
right++
}
if(right-left > max-min) {
max = right-1
min = left+1
}
}
// 映射回原字符的索引
min = Math.floor((min)/2)
max = Math.ceil((max-1)/2)
return s.slice(min, max)
};
时间复杂度：O(n^2)
空间复杂度：O(n)
方法三：动态规划法
思路：利用空间换时间，即对于字符串abcba，如果已经知道bcb是回文字符串，那么abcba是回文字符串仅需满足字符串的首尾元素相同。
用二维数组dp[i][j]存储状态，(i, j)表示回文字符串的起始和结束位置。
由此写出状态转移方程：
dp[i][j] = dp[i+1][j-1] && s[i] === s[j]
翻译过来就是一个起始位置是i, 结束位置是j（包含i, j处的字符）的子串是回文子串的条件是起始位置是i+1, 结束位置是j-1的子串是回文子串且i位置的字符和j位置的字符相同。
另外注意一点，由于 i是起始位置，j是结束位置，则i < j始终成立。这也意味着，对于dp[i][j]，对角线以下部分的值不用考虑，那对角线代表的意思呢？很明显，就是起始位置等于结束位置的字符，其一定是回文。那么可以写出dp数组的初始状态：
var longestPalindrome = function(s) {
let dp = [], size = s.length
for(let i = 0; i < size; i++) {
dp[i] = []
}
for(let i = 0; i < size; i++) {
dp[i][i] = true;
}
}
以下图中的字符为例，s = abccbd，
第一行每一列的值表示起始位置是0，结束位置是j的字符是否是回文
第二行每一列的值表示起始位置是1，结束位置是j的字符是否是回文
...
这里还有一个规律，前面说了，若子串长度是1，则一定是回文，那么若子串长度是2呢？只要满足s[i] === s[j]，子串就是回文。
/**
* 方法三：动态规划
* 时间复杂度：O(n^2) 空间复杂度：O(n^2)
* @param {string} s
* @return {string}
*/
var longestPalindrome = function(s) {
let dp = [], size = s.length
let start = 0, end = 0;
for(let i = 0; i < size; i++) {
dp[i] = []
}
for(let i = 0; i < size; i++) {
dp[i][i] = true;
}
for(let j = 1; j < size; j++) {
for(let i = 0; i < j; i++) {
dp[i][j] = j-i === 1 ? s[i] === s[j] : dp[i+1][j-1] && s[i] === s[j]
if(dp[i][j] && (j-i > end - start)) {
end = j
start = i
}
}
}
return s.slice(start, end+1)
}
可以看到，由于动态规划本来的好处是以空间换时间以降低时间复杂度，但这里动态规划的性能反而是最差的，不过这也是因为回文子串的特点清晰容易找到捷径，在大部分情况下动态规划表现都是很不错的。
最后
寻找回文子串还有一个方法叫Manacher算法，也就是俗称的马拉车算法，此算法着实绕，我看了多次也是稀里糊涂的，我选择放弃。
