参与本项目，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！

> dp(s.size(), vector(s.size(), 0)); int maxlenth = 0; int left = 0; int right = 0; for (int i = s.size() - 1; i >= 0; i--) { for (int j = i; j < s.size(); j++) { if (s[i] == s[j]) { if (j - i <= 1) { // 情况一 和 情况二 dp[i][j] = true; } else if (dp[i + 1][j - 1]) { // 情况三 dp[i][j] = true; } } if (dp[i][j] && j - i + 1 > maxlenth) { maxlenth = j - i + 1; left = i; right = j; } } } return s.substr(left, right - left + 1); } }; ``` 以上代码是为了凸显情况一二三，当然是可以简洁一下的，如下： ```CPP class Solution { public: string longestPalindrome(string s) { vector> dp(s.size(), vector(s.size(), 0)); int maxlenth = 0; int left = 0; int right = 0; for (int i = s.size() - 1; i >= 0; i--) { for (int j = i; j < s.size(); j++) { if (s[i] == s[j] && (j - i <= 1 || dp[i + 1][j - 1])) { dp[i][j] = true; } if (dp[i][j] && j - i + 1 > maxlenth) { maxlenth = j - i + 1; left = i; right = j; } } } return s.substr(left, maxlenth); } }; ``` * 时间复杂度：O(n^2) * 空间复杂度：O(n^2) ## 双指针 动态规划的空间复杂度是偏高的，我们再看一下双指针法。 首先确定回文串，就是找中心然后想两边扩散看是不是对称的就可以了。 **在遍历中心点的时候，要注意中心点有两种情况**。 一个元素可以作为中心点，两个元素也可以作为中心点。 那么有的同学问了，三个元素还可以做中心点呢。其实三个元素就可以由一个元素左右添加元素得到，四个元素则可以由两个元素左右添加元素得到。 所以我们在计算的时候，要注意一个元素为中心点和两个元素为中心点的情况。 **这两种情况可以放在一起计算，但分别计算思路更清晰，我倾向于分别计算**，代码如下： ```CPP class Solution { public: int left = 0; int right = 0; int maxLength = 0; string longestPalindrome(string s) { int result = 0; for (int i = 0; i < s.size(); i++) { extend(s, i, i, s.size()); // 以i为中心 extend(s, i, i + 1, s.size()); // 以i和i+1为中心 } return s.substr(left, maxLength); } void extend(const string& s, int i, int j, int n) { while (i >= 0 && j < n && s[i] == s[j]) { if (j - i + 1 > maxLength) { left = i; right = j; maxLength = j - i + 1; } i--; j++; } } }; ``` * 时间复杂度：O(n^2) * 空间复杂度：O(1) # 其他语言版本 Java： ```java public int[] twoSum(int[] nums, int target) { int[] res = new int[2]; if(nums == null || nums.length == 0){ return res; } Map map = new HashMap<>(); for(int i = 0; i < nums.length; i++){ int temp = target - nums[i]; if(map.containsKey(temp)){ res[1] = i; res[0] = map.get(temp); } map.put(nums[i], i); } return res; } ``` ```java // 双指针 中心扩散法 class Solution { public String longestPalindrome(String s) { String s1 = ""; String s2 = ""; String res = ""; for (int i = 0; i < s.length(); i++) { // 分两种情况：即一个元素作为中心点，两个元素作为中心点 s1 = extend(s, i, i); // 情况1 res = s1.length() > res.length() ? s1 : res; s2 = extend(s, i, i + 1); // 情况2 res = s2.length() > res.length() ? s2 : res; } return res; // 返回最长的 } public String extend(String s, int start, int end){ String tmp = ""; while (start >= 0 && end < s.length() && s.charAt(start) == s.charAt(end)){ tmp = s.substring(start, end + 1); // Java中substring是左闭右开的，所以要+1 // 向两边扩散 start--; end++; } return tmp; } } ``` Python： ```python class Solution: def longestPalindrome(self, s: str) -> str: dp = [[False] * len(s) for _ in range(len(s))] maxlenth = 0 left = 0 right = 0 for i in range(len(s) - 1, -1, -1): for j in range(i, len(s)): if s[j] == s[i]: if j - i <= 1 or dp[i + 1][j - 1]: dp[i][j] = True if dp[i][j] and j - i + 1 > maxlenth: maxlenth = j - i + 1 left = i right = j return s[left:right + 1] ``` 双指针： ```python class Solution: def longestPalindrome(self, s: str) -> str: def find_point(i, j, s): while i >= 0 and j < len(s) and s[i] == s[j]: i -= 1 j += 1 return i + 1, j def compare(start, end, left, right): if right - left > end - start: return left, right else: return start, end start = 0 end = 0 for i in range(len(s)): left, right = find_point(i, i, s) start, end = compare(start, end, left, right) left, right = find_point(i, i + 1, s) start, end = compare(start, end, left, right) return s[start:end] ``` Go： ```go ``` JavaScript： ```js //动态规划解法 var longestPalindrome = function(s) { const len = s.length; // 布尔类型的dp[i][j]：表示区间范围[i,j] （注意是左闭右闭）的子串是否是回文子串，如果是dp[i][j]为true，否则为false let dp = new Array(len).fill(false).map(() => new Array(len).fill(false)); // left起始位置 maxlenth回文串长度 let left = 0, maxlenth = 0; for(let i = len - 1; i >= 0; i--){ for(let j = i; j < len; j++){ // 情况一：下标i 与 j相同，同一个字符例如a，当然是回文子串 j - i == 0 // 情况二：下标i 与 j相差为1，例如aa，也是文子串 j - i == 1 // 情况一和情况二 可以合并为 j - i <= 1 // 情况三：下标：i 与 j相差大于1的时候，例如cabac，此时s[i]与s[j]已经相同了，我们看i到j区间是不是回文子串就看aba是不是回文就可以了，那么aba的区间就是 i+1 与 j-1区间，这个区间是不是回文就看dp[i + 1][j - 1]===true if(s[i] === s[j] && (j - i <= 1 || dp[i + 1][j - 1])){ dp[i][j] = true; } // 只要 dp[i][j] == true 成立，就表示子串 s[i..j] 是回文，此时记录回文长度和起始位置 if(dp[i][j] && j - i + 1 > maxlenth) { maxlenth = j - i + 1; // 回文串长度 left = i; // 起始位置 } } } return s.substr(left, maxlenth); // 找到子串 }; //双指针 var longestPalindrome = function(s) { let left = 0, right = 0, maxLength = 0; const extend = (s, i, j, n) => {// s为字符串 i,j为双指针 n为字符串长度 while(i >= 0 && j < n && s[i] === s[j]){ if(j - i + 1 > maxLength){ left = i; // 更新开始位置 right = j; // 更新结尾位置 maxLength = j - i + 1; // 更新子串最大长度 } // 指针移动 i--; j++; } } for(let i = 0; i < s.length; i++){ extend(s, i, i, s.length); // 以i为中心 extend(s, i, i + 1, s.length); // 以i和i+1为中心 } return s.substr(left, maxLength); }; //Manacher算法 var longestPalindrome = function(s) { const len = s.length; if(len < 2) return s; let maxLength = 1, index = 0; //Manacher算法,利用回文对称的性质，根据i在上一个回文中心的臂长里的位置去判断i的回文性 //需要知道上一个回文中心，以及其臂长 let center = 0; //注意这里使用了maxRight的而不是真实的臂长length,因为之后需要判断i在臂长的什么位置 //如果这里臂长用了length,之后还要 计算i - center 去和 length比较，太繁琐 let maxRight = 0; //考虑到回文串的长度是偶数的情况,所以这里预处理一下字符串,每个字符间插入特殊字符,把可能性都化为奇数 //这个处理把回文串长度的可能性都化为了奇数 //#c#b#b#a# //#c#b#a#b#d# let ss = ""; for(let i = 0; i < s.length; i++){ ss += "#"+s[i]; } ss += "#"; //需要维护一个每个位置臂长的信息数组positionLength const pl = new Array(ss.length).fill(0); //这里需要注意参考的是i关于center对称的点i'的回文性 //i' = 2*center - i; //所以列下情况: //1.i>maxRight,找不到i',无法参考，自己算自己的 //2.i<=maxRight: //2.1 i= pl[i‘],大多少需要尝试扩散 //2.3 i>maxRight-pl[i'],pl[i']的臂长超过了center的臂长,根据对称性,i中心扩散到MaxRight处, // s[2*i-maxRight] !== s[MaxRight]必不相等，所以pl[i] = maxRight-i; //总结就是pl[i] = Math.min(maxRight-i,pl[i']);提示i= 0 && right maxRight){ center = i; maxRight = pl[i] + i; } if (pl[i] * 2 + 1 > maxLength){ maxLength = pl[i]*2+1; index = i - pl[i]; } } return ss.substr(index, maxLength).replace(/#/g,""); }; ``` C： 动态规划： ```c //初始化dp数组，全部初始为false bool **initDP(int strLen) { bool **dp = (bool **)malloc(sizeof(bool *) * strLen); int i, j; for(i = 0; i < strLen; ++i) { dp[i] = (bool *)malloc(sizeof(bool) * strLen); for(j = 0; j < strLen; ++j) dp[i][j] = false; } return dp; } char * longestPalindrome(char * s){ //求出字符串长度 int strLen = strlen(s); //初始化dp数组，元素初始化为false bool **dp = initDP(strLen); int maxLength = 0, left = 0, right = 0; //从下到上，从左到右遍历 int i, j; for(i = strLen - 1; i >= 0; --i) { for(j = i; j < strLen; ++j) { //若当前i与j所指字符一样 if(s[i] == s[j]) { //若i、j指向相邻字符或同一字符，则为回文字符串 if(j - i <= 1) dp[i][j] = true; //若i+1与j-1所指字符串为回文字符串，则i、j所指字符串为回文字符串 else if(dp[i + 1][j - 1]) dp[i][j] = true; } //若新的字符串的长度大于之前的最大长度，进行更新 if(dp[i][j] && j - i + 1 > maxLength) { maxLength = j - i + 1; left = i; right = j; } } } //复制回文字符串，并返回 char *ret = (char*)malloc(sizeof(char) * (maxLength + 1)); memcpy(ret, s + left, maxLength); ret[maxLength] = 0; return ret; } ``` 双指针： ```c int left, maxLength; void extend(char *str, int i, int j, int size) { while(i >= 0 && j < size && str[i] == str[j]) { //若当前子字符串长度大于最长的字符串长度，进行更新 if(j - i + 1 > maxLength) { maxLength = j - i + 1; left = i; } //左指针左移，右指针右移。扩大搜索范围 ++j, --i; } } char * longestPalindrome(char * s){ left = right = maxLength = 0; int size = strlen(s); int i; for(i = 0; i < size; ++i) { //长度为单数的子字符串 extend(s, i, i, size); //长度为双数的子字符串 extend(s, i, i + 1, size); } //复制子字符串 char *subStr = (char *)malloc(sizeof(char) * (maxLength + 1)); memcpy(subStr, s + left, maxLength); subStr[maxLength] = 0; return subStr; } ``` -----------------------