最长回文子串

给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为1000。

示例 1：

输入: "babad"
输出: "bab"
注意: "aba"也是一个有效答案。

示例 2：

输入: "cbbd"
输出: "bb"

这道题 是真有难度啊   我差一点就独立解决了  可惜还是差一点  继续加油 

解题方案：（暴力方法不讲，遍历所有子串）

①

反转S并成为S'。找到S和S'之间最长的公共子串，它也必须是最长的回文子串。

这似乎有用，让我们看下面的一些例子。

例如，
S =“caba”，S'=“abac”。
S和S'之间最长的公共子串是“aba”，这就是答案。

让我们尝试另一个例子：
S =“abacdfgdcaba”，S'=“abacdgfdcaba”。
S和S'之间最长的公共子串是“abacd”。显然，这不是一个有效的回文。

我们可以看到，当S的某些其他部分存在非回文子串的反向副本时，最长的公共子串方法失败。为了纠正这个问题，每次我们找到一个最长的公共子串候选者时，我们检查子串的索引是否与反向子串的原始索引相同。如果是，那么我们尝试更新到目前为止发现的最长的回文; 如果没有，我们跳过这个，找到下一个候选人。

这给了我们一个O（N 2）DP解决方案，它使用O（N 2）空间（可以改进使用O（N）空间）。

②

为了改进DP方法的强力解决方案，首先要考虑如何在验证回文中避免不必要的重新计算。以“ababa”为例。如果我们已经知道“bab”是一个回文，很明显“ababa”必须是回文，因为两个左右两边的字母是相同的。

下面更正式地说明：

如果子串S i ... S j是回文，则定义P [i，j]←true ，否则为假。

因此，

P [i，j]←（P [i + 1，j-1] 和 S i = S j）

基本案例是：

P [i，i]←true 
P [i，i + 1]←（S i = S i + 1）

这产生了一个直接的DP解决方案，我们首先初始化一个和两个字母的回文，然后逐步找到所有三个字母的回文，依此类推...... 

这给了我们运行时复杂度为O（N 2）并使用O（N 2）空间来存储表。

③

一个更简单的方法，O（N 2）时间和O（1）空间：
事实上，我们可以在O（N 2）时间内解决它而没有任何额外的空间。

我们观察到它的中心周围有一个回文镜像。因此，回文可以从其中心扩展，并且只有2N-1个这样的中心。

你可能会问为什么有2N-1而不是N个中心？原因是回文的中心可以在两个字母之间。这些回文具有偶数个字母（例如“abba”），其中心位于两个'b'之间。

由于围绕其中心扩展回文可能需要O（N）时间，因此总体复杂度为O（N 2）。

（我最开始的时候想的就是这种算法，但是忽略了回文的中心是偶数的情况）

public String longestPalindrome(String s) {
    if (s == null || s.length() < 1) return "";
    int start = 0, end = 0;
    for (int i = 0; i < s.length(); i++) {
        int len1 = expandAroundCenter(s, i, i);
        int len2 = expandAroundCenter(s, i, i + 1);
        int len = Math.max(len1, len2);
        if (len > end - start) {
            start = i - (len - 1) / 2;
            end = i + len / 2;
        }
    }
    return s.substring(start, end + 1);
}

private int expandAroundCenter(String s, int left, int right) {
    int L = left, R = right;
    while (L >= 0 && R < s.length() && s.charAt(L) == s.charAt(R)) {
        L--;
        R++;
    }
    return R - L - 1;
}

⑤

O（N）解决方案（Manacher算法）：
首先，我们通过在字母之间插入一个特殊字符“＃”将输入字符串S转换为另一个字符串T. 这样做的原因很快就会清楚。

例如：S =“abaaba”，T =“＃a＃b＃a #a＃b #a＃”。

为了找到最长的回文子串，我们需要在每个T i周围扩展，使得T i-d ... T i + d形成回文。您应该立即看到d是以T i为中心的回文长度。

我们将中间结果存储在数组P中，其中P [i]等于T i处的回文中心的长度。最长的回文子串将是P中的最大元素。

使用上面的例子，我们填充P如下（从左到右）：

<span style="color:#666666">T =＃a＃b＃a＃a＃b＃a＃
P = 0 1 0 3 0 1 6 1 0 3 0 1 0</span>

看着P，我们立即看到最长的回文是“abaaba”，如P 6 = 6所示。

您是否注意到在字母之间插入特殊字符（＃），是否优雅地处理了奇数和偶数长度的回文？（请注意：这是为了更容易地演示这个想法，并不一定需要对算法进行编码。）

现在，想象一下你在回文“abaaba”的中心画一条想象的垂直线。你注意到P中的数字是围绕这个中心对称的吗？不仅如此，尝试另一个回文“aba”，这些数字也反映出类似的对称属性。这是巧合吗？答案是肯定的，不是。这只适用于条件，但无论如何，我们有很大的进步，因为我们可以消除重新计算P [i]的部分。

让我们继续进行一个稍微复杂的例子，其中有一些重叠的回文，其中S =“babcbabcbaccba”。

上图显示T从S =“babcbabcbaccba”转换而来。假设您已达到表P部分完成的状态。实线垂直线表示回文“abcbabcba”的中心（C）。两条虚线垂直线分别表示其左（L）和右（R）边缘。你在索引i，它在C周围的镜像索引是我。你如何有效地计算P [i]？

假设我们已经到达指数i = 13，我们需要计算P [13]（由问号？表示）。我们首先看一下它在palindrome的中心C周围的镜像索引，即索引i'= 9。

上面的两条绿色实线表示以i和i'为中心的两个回文区域的覆盖区域。我们看看C周围的镜像索引，即索引i'。P [i'] = P [9] = 1.很明显，P [i]也必须为1，这是由于回文的中心周围的对称性质。

正如您在上面所看到的，很明显P [i] = P [i'] = 1，由于回文中心周围的对称性质，它必须是真的。实际上，C之后的所有三个元素都遵循对称性（即P [12] = P [10] = 0，P [13] = P [9] = 1，P [14] = P [8] = 0）。

现在我们在索引i = 15，它在C周围的镜像索引是i'= 7. P [15] = P [7] = 7？

现在我们在索引i = 15.P [i]的值是多少？如果我们遵循对称属性，P [i]的值应该与P [i'] = 7相同。但这是错误的。如果我们在T 15处围绕中心扩展，它形成了一个回文“a＃b＃c＃b＃a”，它实际上比它的对称对应物更短。为什么？

在索引i和i'处围绕中心重叠彩色线。由于C周围的对称属性，绿色实线显示两侧必须匹配的区域。红色实线表示两侧可能不匹配的区域。虚线绿线表示穿过中心的区域。

很明显，由两条实线绿线表示的区域中的两个子串必须完全匹配。中心区域（由绿色虚线表示）也必须是对称的。仔细注意P [i']是7并且它一直延伸到回文的左边缘（L）（由实线红线表示），它不再落在回文的对称性质之下。我们所知道的是P [i] ≥5，并且为了找到P [i]的实数值，我们必须通过扩展经过右边缘（R）来进行字符匹配。在这种情况下，由于P [21]≠P [1]，我们得出结论P [i] = 5。

让我们总结一下这个算法的关键部分如下：

如果 P [i']≤R-i，
则 P [i]←P [i'] 
否则 P [i]≥P[i']。（我们必须扩展经过右边缘（R）才能找到P [i]。

看看它有多优雅？如果你能够完全掌握上述总结，你已经获得了这个算法的本质，这也是最难的部分。

最后一部分是确定我们何时应将C的位置与R一起移动到右侧，这很容易：

如果以i为中心的回文确实扩展到R，我们将C更新为i，（这个新回文的中心），并将R扩展到新回文的右边缘。

在每个步骤中，有两种可能性。如果P [i]≤R - i，我们将P [i]设置为P [i']，它只需要一步。否则，我们尝试通过从右边缘R开始扩展它来将回文的中心改为i。扩展R（内部回路）最多总共需要N步，定位和测试每个中心总共需要N步太。因此，该算法保证最多完成2 * N步，给出线性时间解。

直接给出算法作者提供的C++解决方案

// Transform S into T.
// For example, S = "abba", T = "^#a#b#b#a#$".
// ^ and $ signs are sentinels appended to each end to avoid bounds checking
string preProcess(string s) {
  int n = s.length();
  if (n == 0) return "^$";
  string ret = "^";
  for (int i = 0; i < n; i++)
    ret += "#" + s.substr(i, 1);
 
  ret += "#$";
  return ret;
}
 
string longestPalindrome(string s) {
  string T = preProcess(s);
  int n = T.length();
  int *P = new int[n];
  int C = 0, R = 0;
  for (int i = 1; i < n-1; i++) {
    int i_mirror = 2*C-i; // equals to i' = C - (i-C)
    
    P[i] = (R > i) ? min(R-i, P[i_mirror]) : 0;
    
    // Attempt to expand palindrome centered at i
    while (T[i + 1 + P[i]] == T[i - 1 - P[i]])
      P[i]++;
 
    // If palindrome centered at i expand past R,
    // adjust center based on expanded palindrome.
    if (i + P[i] > R) {
      C = i;
      R = i + P[i];
    }
  }
 
  // Find the maximum element in P.
  int maxLen = 0;
  int centerIndex = 0;
  for (int i = 1; i < n-1; i++) {
    if (P[i] > maxLen) {
      maxLen = P[i];
      centerIndex = i;
    }
  }
  delete[] P;
  
  return s.substr((centerIndex - 1 - maxLen)/2, maxLen);
}