题目：
给定一个字符串
s，找到s中最长的回文子串。你可以假设s的最大长度为 1000。示例 1：
输入: "babad" 输出: "bab" 注意: "aba" 也是一个有效答案。示例 2：
输入: "cbbd" 输出: "bb"
刚开始我的思路:
最开始我也不知道回文是什么意思，但是我按照自己的理解，也能够理解题目啥意思，大概就是如果一个字符串前后有相同的字符，那么包括它在内的组成了最长子串。
所以我的编程思路大概就是，首先遍历字符串，然后将每个字符串存入一个新的列表当中，存入前判断，存入的字符是否已经在列表当中，如果在，那么说明他们之前的字符串组成了 最长子串，然后写下了如下代码：
class Solution:
def longestPalindrome(self, s):
"""
:type s: str
:rtype: str
"""
if (s == null or len(s) < 1) return "";
str_num = []
new_str ='' # 有重复
for i in s:
if i in str_num:
index = 0;
for j in range(len(str_num)): # 找到最开始的索引
if str_num[j] == i:
index = j
for a in range(index, len(str_num)): # 拼接新字符串
new_str += str_num[a]
new_str += i # 加上结尾
return new_str
new_str = ''
str_num.append(i)
return s[-1:]
感觉还是挺简单的，执行的时候，自己的测试用例都能通过，但是提交就不能过用例。分析原因，考虑的情况太少了。没能完全理解回文，然后查看了答案，和别人的解法：补充完整。
class Solution:
def longestPalindrome(self, s):
"""
:type s: str
:rtype: str
"""
str = ""
for i in range(2*len(s)-1):
if i%2 == 0:
start = end = i//2
while start>=0 and end<len(s) and s[start]==s[end]:
start-=1
end+=1
else:
start = (i-1) // 2
end = (i+1) //2
while start>=0 and end<len(s) and s[start]==s[end]:
start-=1
end+=1
if len(str)<=(end-start-1):
str=s[start+1:end]
return str官方思路以及解答：
摘要
这篇文章是为中级读者而写的。它介绍了回文，动态规划以及字符串处理。请确保你理解什么是回文。回文是一个正读和反读都相同的字符串，例如，\textrm{“aba”}“aba” 是回文，而 \textrm{“abc”}“abc” 不是。
解决方案
方法一：最长公共子串
常见错误
有些人会忍不住提出一个快速的解决方案，不幸的是，这个解决方案有缺陷(但是可以很容易地纠正)：
反转 SS，使之变成 S'S′。找到 SS 和 S'S′ 之间最长的公共子串，这也必然是最长的回文子串。
这似乎是可行的，让我们看看下面的一些例子。
例如，S = \textrm{“caba”}S=“caba” , S' = \textrm{“abac”}S′=“abac”：
SS 以及 S'S′ 之间的最长公共子串为 \textrm{“aba”}“aba”，恰恰是答案。
让我们尝试一下这个例子：S = \textrm{“abacdfgdcaba”}S=“abacdfgdcaba” , S' = \textrm{“abacdgfdcaba”}S′=“abacdgfdcaba”：
SS 以及 S'S′ 之间的最长公共子串为 \textrm{“abacd”}“abacd”，显然，这不是回文。
算法
我们可以看到，当 SS 的其他部分中存在非回文子串的反向副本时，最长公共子串法就会失败。为了纠正这一点，每当我们找到最长的公共子串的候选项时，都需要检查子串的索引是否与反向子串的原始索引相同。如果相同，那么我们尝试更新目前为止找到的最长回文子串；如果不是，我们就跳过这个候选项并继续寻找下一个候选。
这给我们提供了一个复杂度为 O(n^2)O(n2) 动态规划解法，它将占用 O(n^2)O(n2) 的空间（可以改进为使用 O(n)O(n) 的空间）。请在这里阅读更多关于最长公共子串的内容。
方法二：暴力法
很明显，暴力法将选出所有子字符串可能的开始和结束位置，并检验它是不是回文。
复杂度分析
时间复杂度：O(n^3)O(n3)，假设 nn 是输入字符串的长度，则 \binom{n}{2} = \frac{n(n-1)}{2}(2n)=2n(n−1) 为此类子字符串(不包括字符本身是回文的一般解法)的总数。因为验证每个子字符串需要 O(n)O(n) 的时间，所以运行时间复杂度是 O(n^3)O(n3)。
空间复杂度：O(1)O(1)。
方法三：动态规划
为了改进暴力法，我们首先观察如何避免在验证回文时进行不必要的重复计算。考虑 \textrm{“ababa”}“ababa” 这个示例。如果我们已经知道 \textrm{“bab”}“bab” 是回文，那么很明显，\textrm{“ababa”}“ababa” 一定是回文，因为它的左首字母和右尾字母是相同的。
我们给出 P(i,j)P(i,j) 的定义如下：
P(i,j) = \begin{cases} \text{true,} &\quad\text{如果子串} S_i \dots S_j \text{是回文子串}\\ \text{false,} &\quad\text{其它情况} \end{cases}P(i,j)={true,false,如果子串Si…Sj是回文子串其它情况
因此，
P(i, j) = ( P(i+1, j-1) \text{ and } S_i == S_j )P(i,j)=(P(i+1,j−1) and Si==Sj)
基本示例如下：
P(i, i) = trueP(i,i)=true
P(i, i+1) = ( S_i == S_{i+1} )P(i,i+1)=(Si==Si+1)
这产生了一个直观的动态规划解法，我们首先初始化一字母和二字母的回文，然后找到所有三字母回文，并依此类推…
复杂度分析
时间复杂度：O(n^2)O(n2)， 这里给出我们的运行时间复杂度为 O(n^2)O(n2) 。
空间复杂度：O(n^2)O(n2)， 该方法使用 O(n^2)O(n2) 的空间来存储表。
补充练习
你能进一步优化上述解法的空间复杂度吗？
方法四：中心扩展算法
事实上，只需使用恒定的空间，我们就可以在 O(n^2)O(n2) 的时间内解决这个问题。
我们观察到回文中心的两侧互为镜像。因此，回文可以从它的中心展开，并且只有 2n - 12n−1 个这样的中心。
你可能会问，为什么会是 2n - 12n−1 个，而不是 nn 个中心？原因在于所含字母数为偶数的回文的中心可以处于两字母之间（例如 \textrm{“abba”}“abba” 的中心在两个 \textrm{‘b’}‘b’ 之间）。
复杂度分析
时间复杂度：O(n^2)O(n2)， 由于围绕中心来扩展回文会耗去 O(n)O(n) 的时间，所以总的复杂度为 O(n^2)O(n2)。
空间复杂度：O(1)O(1)。
------------------------------------分界线 20190226-------------------------------------------------------------------------------------------------------------动态规划：
具体可参考：https://www.sohu.com/a/153858619_466939
下面介绍动态规划的方法，使用动态规划可以达到最优的 O(n2) 复杂度。
令 dp[i][j] 表示 S[i] 至 S[j] 所表示的子串是否是回文子串，是则为 1，不是则为 0。这样根据 S[i] 是否等于 S[j] ，可以把转移情况分为两类：
-
- 若 S[i] == S[j]，那么只要 S[i+1] 至 S[j-1] 是回文子串，S[i] 至 S[j] 就是回文子串；如果S[i+1] 至 S[j-1] 不是回文子串，则 S[i] 至 S[j] 也不是回文子串。
- 若 S[i] != S[j]，那么 S[i] 至 S[j] 一定不是回文子串。
由此可以写出状态转移方程：
dp[i][j]={dp[i+1][j−1],S[i]==S[j]0,S[i]!=S[j]dp[i][j]={dp[i+1][j−1],S[i]==S[j]0,S[i]!=S[j]
边界：dp[i][i]=1，dp[i][i+1] = (S[i] == S[i+1]) ? 1 : 0。
根据递推写法从边界出发的原理，注意到边界表示的是长度为 1 和 2 的子串，且每次转移时都对子串的长度减了 1，因此不妨考虑按子串的长度和子串的初始位置进行枚举，即第一遍将长度为 3 的子串的 dp 值全部求出，第二遍通过第一遍结果计算出长度为 4 的子串的 dp 值 ……
/*
2 最长回文子串
3 */
4
5 #include <stdio.h>
6 #include <string.h>
7 #include <math.h>
8 #include <stdlib.h>
9 #include <time.h>
10 #include <stdbool.h>
11
12 #define maxn 1010
13 char S[maxn];
14 int dp[maxn][maxn];
15
16 int main() {
17 gets(S); // 输入整行字符
18 int len=strlen(S), ans=1; // ans 记录最长回文子串长度
19 int i, j, L;
20 // 边界
21 for(i=0; i<len; ++i) {
22 dp[i][i] = 1;
23 if(i < len-1) {
24 if(S[i] == S[i+1]) {
25 dp[i][i+1] = 1;
26 ans = 2;
27 }
28 }
29 }
30 // 状态转移方程
31 for(L=3; L<=len; ++L) { // 枚举子串长度
32 for(i=0; i+L-1 < len; ++i) { // 枚举子串的起始节点
33 j = i+L-1; // 子串的右端结点
34 if(S[i]==S[j] && dp[i+1][j-1]==1) {
35 dp[i][j] = 1;
36 ans = L; // 更新最长回文子串长度
37 }
38 }
39 }
40 printf("%d\n", ans); // 输出
41
42 return 0;
43 }