在花了大约6到8个小时尝试消化Manacher的算法后，我准备投入工作。但是在我这样做之前，这是黑暗中的最后一枪：有人能解释吗？我不在乎代码。我希望有人来解释该算法。

这似乎是其他人似乎喜欢解释该算法的地方：http : //www.leetcode.com/2011/11/longest-palindromic-substring-part-ii.html

我知道您为什么要将字符串转换为“ abba”到＃a＃b＃b＃a＃，然后我迷路了。例如，前面提到的网站的作者说，算法的关键部分是：

                      if P[ i' ] ≤ R – i,
                      then P[ i ] ← P[ i' ]
                      else P[ i ] ≥ P[ i' ]. (Which we have to expand past 
                      the right edge (R) to find P[ i ])

这似乎是错误的，因为他/她曾说过，当P [i'] = 7且P [i]不小于或等于R-i时，P [i]等于5。

如果您不熟悉该算法，请参见以下更多链接：http : //tristan-interview.blogspot.com/2011/11/longest-palindrome-substring-manachers.html（我已经尝试过此方法，但是术语令人恐惧和混乱。首先，未定义某些内容。此外，变量太多。您需要一个清单来回忆一下什么变量指的是什么。）

另一个是：http : //www.akalin.cx/longest-palindrome-linear-time（祝您好运）

该算法的基本要点是找到线性时间最长的回文。可以在O（n ^ 2）中完成最小到中等的工作量。该算法被认为是相当“聪明”的，可以降低到O（n）。

我同意在链接说明中逻辑不正确。我在下面提供一些细节。

Manacher的算法填写表格P [i]，其中包含以i为中心的回文延伸了多远。如果P [5] = 3，则位置5两侧的三个字符是回文的一部分。该算法利用了以下事实：如果您发现了一个长回文，您可以通过查看左侧的P值来快速填充回文右侧的P值，因为它们大部分应该是相同。

我将首先解释您所讨论的情况，然后根据需要扩展此答案。

R指示回文右侧以C为中心的索引。这是您指示的位置的状态：

C=11
R=20
i=15
i'=7
P[i']=7
R-i=5

逻辑是这样的：

if P[i']<=R-i:  // not true
else: // P[i] is at least 5, but may be greater

链接中的伪代码表明，如果测试失败，则P [i]应大于或等于P [i']，但我认为它应大于或等于Ri，并对此进行了支持。

由于P [i']大于Ri，所以以i'为中心的回文延伸到以C为中心的回文。我们知道以i为中心的回文至少要有Ri个字符宽，因为到目前为止，我们仍然具有对称性，但是我们必须明确搜索。

如果P [i']不大于Ri，则以i'为中心的最大回文在以C为中心的最大回文中，因此我们知道P [i]不能大于P [i] ']。如果是这样，我们就会有矛盾。这意味着我们可以将以i为中心的回文扩展到P [i']之上，但是如果可以的话，由于对称性，我们也可以将以i为中心的回文扩展出来，但是它已经应该尽可能大。

前面已经说明了这种情况：

C=11
R=20
i=13
i'=9
P[i']=1
R-i=7

在这种情况下，P [i'] <= Ri。由于距以C为中心的回文边缘还相距7个字符，因此我们知道i周围至少有7个字符与i'周围的7个字符相同。由于i'周围只有一个字符的回文，因此i周围也只有一个字符的回文。

j_random_hacker注意到逻辑应该更像这样：

if P[i']<R-i then
  P[i]=P[i']
else if P[i']>R-i then
  P[i]=R-i
else P[i]=R-i + expansion

如果P [i'] <Ri，则我们知道P [i] == P [i']，因为我们仍然位于以C为中心的回文内部。

如果P [i']> Ri，那么我们知道P [i] == Ri，因为否则，以C为中心的回文式将延伸到R之外。

因此，仅在P [i'] == Ri的特殊情况下才真正需要扩展，因此我们不知道P [i]的回文是否可能更长。

通过设置P [i] = min（P [i']，Ri），然后始终进行扩展，可以在实际代码中进行处理。这种方式不会增加时间复杂度，因为如果不需要扩展，则扩展所需的时间是恒定的。

我在以下链接中找到了迄今为​​止最好的解释之一：

http://tarokuriyama.com/projects/palindrome2.php

它还具有该问题中提到的第一个链接所使用的相同字符串示例（babcbabcbaccba）的可视化效果。

除了此链接，我还在以下位置找到了代码

http://algs4.cs.princeton.edu/53substring/Manacher.java.html

我希望它对尝试理解该算法关键的其他人有所帮助。

在某种程度上，该站点上的算法似乎可以理解 http://www.akalin.cx/longest-palindrome-linear-time

要了解这种特定方法，最好的方法是尝试在纸上解决问题并掌握可以实施的技巧，从而避免对每个可能的中心进行回文检查。

首先回答自己-当您找到一个给定长度的回文，比如说5-您下一步不能跳到该回文的末尾（跳过4个字母和4个中字母）吗？

如果您尝试创建一个长度为8的回文集，并放置另一个长度> 8的回文集，则该中心位于第一个回文集的右侧，您会发现一些有趣的东西。尝试一下：长度为8的回文式-WOWILIKEEKIL-Like + ekiL = 8现在，在大多数情况下，您可以写下两个E作为中心，数字8作为长度之间的位置，并在最后一个L之后跳转大回文的中心。

这种方法是不正确的，因为较大回文的中心可能在ekiL内，如果您在最后一个L之后跳下去，就会错过它。

找到LIKE + EKIL之后，将8放入这些算法使用的数组中，如下所示：

[0,1,0,3,0,1,0,1,0,3,0,1,0,1,0,1,8]

对于

[＃，W，＃，O，＃，W，＃，I，＃，L，＃，I，＃，K，＃，E，＃]

诀窍是您已经知道8之后的下一个7（8-1）数字很可能与左侧的数字相同，因此下一步是自动将7的数字从8的左侧复制到8的右侧，以保持介意他们还没有最终。数组看起来像这样

[0,1,0,3,0,1,0,1,0,3,0,1,0,1,0,1,8,1,0,1,0,1,0,3]（我们在8）

对于

[＃，W，＃，O，＃，W，＃，I，＃，L，＃，I，＃，K，＃，E，＃，E，＃，K，＃，I，＃，L]

让我们举个例子，这种跳跃会破坏我们当前的解决方案，并看到我们可以注意到的事情。

WOWILIKEEKIL-让中心在EKIL内的某个地方尝试做更大的回文。但这是不可能的-我们需要将EKIL单词更改为包含回文的单词。什么？OOOOOh-就是这样。在我们当前回文的右侧以中心为中心的更大回文的唯一可能性是它已经在回文的右侧（和左侧）。

让我们尝试基于WOWILIKEEKIL构建一个。我们需要将EKIL更改为以I为更大回文中心的EKIK-记住也将LIKE更改为KIKE。我们棘手的回文的首字母为：

WOWIKIKEEKIK

如前所述-让最后一个我成为比KIKEEKIK大的pallindrome的中心：

WOWIKIKEEKIKEEKIKIW

让我们将阵列制作成我们以前的pallindrom，并了解如何处理其他信息。

对于

[_ W _ O _ W _ I _ K _ I _ K _ E _ E _ K _ I _ K _ E _ E _ K _ I _ K _ I _ W]

它将是[0,1,0,3,0,1,0,1,0,3,0,3,0,1,0,1,8

我们知道，下一个我-第三名将是最长的回盲症，但让我们暂时忘记它。让我们将数组中的数字从8的左侧复制到右侧（8个数字）

[0,1,0,3,0,1,0,1,0,3,0,3,0,1,0,1,8,1,0,1,0,3,0,3]

在我们的循环中，我们处于8的E之间。I（最大的前四位综合征的中间）有什么特别之处，我们不能直接跳到K（当前的最大四通症的最后一个字母）？特殊的是它超出了数组的当前大小……怎么办？如果将3个空格向3的右边移动-您将无法使用数组。这意味着它可能是最大的回肠综合征的中间，而您跳得最高的就是这封字母I。

很抱歉这个答案的长度-我想解释一下算法并可以向您保证-@OmnipotentEntity是正确的-向您解释后我理解得更好:)

全文：http : //www.zrzahid.com/longest-palindromic-substring-in-linear-time-manachers-algorithm/

首先，让我们仔细观察回文以发现一些有趣的特性。例如，S1 =“ abaaba”和S2 =“ abcba”，都是回文，但是它们之间的非平凡（即长度或字符）区别是什么？S1是一个回文集，中心位于i = 2和i = 3之间的不可见空间（不存在的空间！）。另一方面，S2以字符i = 2（即c）为中心。为了方便地处理回文的中心，而与奇数/偶数长度无关，让我们通过在字符之间插入特殊字符$来变换回文。然后将S1 =“ abba”和S2 =“ abcba”转换为以i = 6为中心的T1 =“ $ a $ b $ a $ a $ b $ a $”和T2 =“ $ a $ b $ c $ b $ a $”以i = 5为中心。现在，我们可以看到存在中心并且长度一致2 * n + 1，其中n =原始字符串的长度。例如，

                    我是           
      -------------------------------------------------- ---
      | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 |
      -------------------------------------------------- --- 
   T1 = | $ | 一个| $ | b | $ | 一个| $ | 一个| $ | b | $ | 一个| $ |
      -------------------------------------------------- ---

接下来，从中心c周围的一个（已变换的）回文体T的对称性质观察到，对于0 <= k <= c，T [ck] = T [c + k]。也就是说，位置ck和c + k相互镜像。换句话说，对于中心c右边的索引i，镜像索引i'在c的左边，这样c-i'= ic => i'= 2 * ci，反之亦然。那是，

对于回文子串中心c右侧的每个位置i，i的镜像位置为i'= 2 * ci，反之亦然。

让我们定义一个数组P [0..2 * n]，使P [i]等于以i为中心的回文的长度。请注意，长度实际上是通过原始字符串中的字符数来衡量的（通过忽略特殊字符$）。还令min和max分别为以c为中心的回文子串的最左边界和最右边界。因此，min = cP [c]和max = c + P [c]。例如，对于回文S =“ abaaba”，转换后的回文T，镜像中心c = 6，长度数组P [0..12]，min = cP [c] = 6-6 = 0，max = c + P [c] = 6 + 6 = 12，下图显示了两个样本镜像索引i和i'。

      最小我最大
      -------------------------------------------------- ---
      | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 |
      -------------------------------------------------- --- 
    T = | $ | 一个| $ | b | $ | 一个| $ | 一个| $ | b | $ | 一个| $ |
      -------------------------------------------------- ---
    P = | 0 | 1 | 0 | 3 | 0 | 5 | 6 | 1 | 0 | 3 | 0 | 1 | 0 |
      -------------------------------------------------- ---

使用这样的长度数组P，我们可以通过查看P的max元素来找到最长回文子串的长度。

P [i]是回文串T的回文子串的长度，中心在i处，即。在原始字符串S中以i / 2为中心；因此，最长回文子串将是从索引（i _max -P [i _max ]）/ 2开始的长度P [i _max ]的子串，以使i _max是P中最大元素的索引。

下面，我们为非回文示例字符串S =“ babaabca”绘制一个相似的图。

                       最小c最大
                       | ---------------- | ----------------- |
      -------------------------------------------------- ------------------
 idx = | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 |
      -------------------------------------------------- ------------------- 
    T = | $ | b | $ | 一个| $ | b | $ | 一个| $ | 一个| $ | b | $ | c | $ | 一个| $ |
      -------------------------------------------------- -------------------
    P = | 0 | 1 | 0 | 3 | 0 | 3 | 0 | 1 | 4 | 1 | 0 | 1 | 0 | 1 | 0 | 1 | 0 |
      -------------------------------------------------- -------------------

问题是如何有效地计算P。对称属性表明以下情况，我们可以通过在左侧的镜像索引i'处使用先前计算的P [i']来潜在地计算P [i]，从而跳过许多计算。假设我们有一个参考回文（第一个回文）。

1. 如果第二回文在第一个回文的边界内，则第三个回文的中心与锚定在左侧镜中心的第二个回文的长度完全相同。至少一个字符。

   例如，在下图中，第一回文以c = 8为中心，并以min = 4和max = 12为界，第三回文的长度以i = 9为中心（镜像索引i'= 2 * ci = 7）为，P [i] = P [i'] =1。这是因为以i'为中心的第二回文在第一回文的范围内。同样，P [10] = P [6] = 0。

   
                                         | ---- 3rd ---- |
                                 | ----第二个---- |        
                          | ----------- 1st Palindrome --------- |
                          最小我最大
                          | ------------ | --- | --- || ------------- |
         -------------------------------------------------- ------------------
    idx = | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 |
         -------------------------------------------------- ------------------- 
       T = | $ | b | $ | 一个| $ | b | $ | 一个| $ | 一个| $ | b | $ | c | $ | 一个| $ |
         -------------------------------------------------- -------------------
       P = | 0 | 1 | 0 | 3 | 0 | 3 | 0 | 1 | 4 | ？| ？| ？| ？| ？| ？| ？| ？|
         -------------------------------------------------- -------------------
   

   现在，问题是如何检查这种情况？注意，由于对称属性，段[min..i']的长度等于段[i..max]的长度。另外，请注意，如果第二个回文的左边缘在左边界内，则距离第二个回文完全在第一个回文之内。那是，

           i'-P [i']> =分钟
           => P [i']-i'<-min（取反）
           => P [i'] <i'-min 
           => P [i'] <max-i [（max-i）=（i'-min）由于对称性质]。
   

   结合案例1的所有事实

   P [i] = P [i']，当（max-i）> P [i']

2. 如果第二回文馆遇到或延伸到第一回文馆的左边界之外，则可以保证第三回文馆从其自身的中心到第一回文馆的最外面的特征的长度至少为一。从第二个回文的中心到第一个回文的左最外面的字符的长度是相同的。

   例如，在下图中，以i = 5为中心的第二回文延伸到第一回文的左边界之外。因此，在这种情况下，我们不能说P [i] = P [i']。但是第三回文以i = 11为中心的长度，P [i]至少是从其中心i = 11到以c为中心的第一回文的右边界max = 12的长度。即，P [i]＞ ＝ 1。这意味着当且仅当超过max的下一个立即数与镜像字符完全匹配时，第三回文才可以扩展到max以后，并且我们继续进行此检查。例如，在这种情况下，P [13]！= P [9]并且无法扩展。因此，P [i] = 1。

                                                       
                 | ------第二回文------ | | ---- 3rd ---- | ---？    
                          | ----------- 1st Palindrome --------- |
                          最小我最大
                          | ---- | ------------- || ----------- | ----- |
         -------------------------------------------------- ------------------
    idx = | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 |
         -------------------------------------------------- ------------------- 
       T = | $ | b | $ | 一个| $ | b | $ | 一个| $ | 一个| $ | b | $ | c | $ | 一个| $ |
         -------------------------------------------------- -------------------
       P = | 0 | 1 | 0 | 3 | 0 | 3 | 0 | 1 | 4 | 1 | 0 | ？| ？| ？| ？| ？| ？|
         -------------------------------------------------- -------------------
   

   那么，如何检查这种情况？这只是案例1的失败检查。也就是说，第二回文将延伸到第一回文iff的左边缘，

           i'-P [i'] <分钟
           => P [i']-i'> = -min [取反]
           => P [i']> = i'-min 
           => P [i']> = max-i [（max-i）=（i'-min）由于对称性质]。 
   

   也就是说，P [i]至少是（max-i）iff（max-i）P [i]> =（max-i），iff（max-i）现在，如果第三回文确实超过了max，则我们需要更新新回文的中心和边界。

   如果以i为中心的回文确实超过了max，则我们有新的（扩展的）回文，因此在c = i处有一个新的中心。将max更新到新回文的最右边边界。

   结合案例1和案例2的所有事实，我们可以得出一个非常漂亮的小公式：

           情况1：P [i] = P [i']，当（max-i）> P [i']
           情况2：P [i]> =（max-i），iff（max-i）= min（P [i']，max-i）。 
   

   即，当第三回文不能扩展到超过最大值时，P [i] = min（P [i']，max-i）。否则，我们在中心c = i处有新的第三回文，新的max = i + P [i]。

3. 第一回文和第二回文都没有提供信息来帮助确定第四回文的回文长度，第四回文的中心在第一回文的右侧之外。

   也就是说，如果i> max，我们无法抢先确定P [i]。那是，

   P [i] = 0，当max-i <0时

   结合所有情况，我们得出以下公式：

   P [i] = max> i？min（P [i']，max-i）：0。如果我们可以扩展超过max，则可以通过将超出max的字符与镜像字符相对于c = i的新中心进行匹配来扩展。最后，当我们出现不匹配时，我们将更新新的max = i + P [i]。

参考：Wiki页面中的算法描述

我使用动画图形制作了有关此算法的视频。希望它将帮助您理解它！ https://www.youtube.com/watch?v=kbUiR5YWUpQ

此材料对我理解它有很大帮助：http : //solutionleetcode.blogspot.com/2013/07/leetcode-longest-palindromic-substring.html

将T定义为以每个字符为中心的最长回文子字符串的长度。

关键是，当较小的回文完全嵌入较长的回文中时，T [i]在较长的回文中也应对称。

否则，我们将不得不从头开始计算T [i]，而不是从对称的左侧部分中得出。

class Palindrome
{
    private int center;
    private int radius;

    public Palindrome(int center, int radius)
    {
        if (radius < 0 || radius > center)
            throw new Exception("Invalid palindrome.");

        this.center = center;
        this.radius = radius;
    }

    public int GetMirror(int index)
    {
        int i = 2 * center - index;

        if (i < 0)
            return 0;

        return i;
    }

    public int GetCenter()
    {
        return center;
    }

    public int GetLength()
    {
        return 2 * radius;
    }

    public int GetRight()
    {
        return center + radius;
    }

    public int GetLeft()
    {
        return center - radius;
    }

    public void Expand()
    {
        ++radius;
    }

    public bool LargerThan(Palindrome other)
    {
        if (other == null)
            return false;

        return (radius > other.radius);
    }

}

private static string GetFormatted(string original)
{
    if (original == null)
        return null;
    else if (original.Length == 0)
        return "";

    StringBuilder builder = new StringBuilder("#");
    foreach (char c in original)
    {
        builder.Append(c);
        builder.Append('#');
    }

    return builder.ToString();
}

private static string GetUnFormatted(string formatted)
{
    if (formatted == null)
        return null;
    else if (formatted.Length == 0)
        return "";

    StringBuilder builder = new StringBuilder();
    foreach (char c in formatted)
    {
        if (c != '#')
            builder.Append(c);
    }

    return builder.ToString();
}

public static string FindLargestPalindrome(string str)
{
    string formatted = GetFormatted(str);

    if (formatted == null || formatted.Length == 0)
        return formatted;

    int[] radius = new int[formatted.Length];

    try
    {
        Palindrome current = new Palindrome(0, 0);
        for (int i = 0; i < formatted.Length; ++i)
        {
            radius[i] = (current.GetRight() > i) ?
                Math.Min(current.GetRight() - i, radius[current.GetMirror(i)]) : 0;

            current = new Palindrome(i, radius[i]);

            while (current.GetLeft() - 1 >= 0 && current.GetRight() + 1 < formatted.Length &&
                formatted[current.GetLeft() - 1] == formatted[current.GetRight() + 1])
            {
                current.Expand();
                ++radius[i];
            }
        }

        Palindrome largest = new Palindrome(0, 0);
        for (int i = 0; i < radius.Length; ++i)
        {
            current = new Palindrome(i, radius[i]);
            if (current.LargerThan(largest))
                largest = current;
        }

        return GetUnFormatted(formatted.Substring(largest.GetLeft(), largest.GetLength()));
    }
    catch (Exception ex) 
    {
        Console.WriteLine(ex);
    }

    return null;
}

查找字符串中最长回文的快速Javascript解决方案：

const lpal = str => {
  let lpal = ""; // to store longest palindrome encountered
  let pal = ""; // to store new palindromes found
  let left; // to iterate through left side indices of the character considered to be center of palindrome
  let right; // to iterate through left side indices of the character considered to be center of palindrome
  let j; // to iterate through all characters and considering each to be center of palindrome
  for (let i=0; i<str.length; i++) { // run through all characters considering them center of palindrome
    pal = str[i]; // initializing current palindrome
    j = i; // setting j as index at the center of palindorme
    left = j-1; // taking left index of j
    right = j+1; // taking right index of j
    while (left >= 0 && right < str.length) { // while left and right indices exist
      if(str[left] === str[right]) { //
        pal = str[left] + pal + str[right];
      } else {
        break;
      }
      left--;
      right++;
    }
    if(pal.length > lpal.length) {
      lpal = pal;
    }
    pal = str[i];
    j = i;
    left = j-1;
    right = j+1;
    if(str[j] === str[right]) {
      pal = pal + str[right];
      right++;
      while (left >= 0 && right < str.length) {
        if(str[left] === str[right]) {
          pal = str[left] + pal + str[right];
        } else {
          break;
        }
        left--;
        right++;
      }
      if(pal.length > lpal.length) {
        lpal = pal;
      }
    }
  }
  return lpal;
}

输入示例

console.log(lpal("gerngehgbrgregbeuhgurhuygbhsbjsrhfesasdfffdsajkjsrngkjbsrjgrsbjvhbvhbvhsbrfhrsbfsuhbvsuhbvhvbksbrkvkjb"));

输出量

asdfffdsa

我经历了同样的挫折/挣扎，并且在此页面https://www.hackerearth.com/practice/algorithms/string-algorithm/manachars-algorithm/tutorial/上找到了解决方案，这是最容易理解的。我尝试以自己的方式实现此解决方案，我想我现在可以理解该算法。我还尝试在代码中填充尽可能多的解释，以解释算法。希望有帮助！

#Manacher's Algorithm
def longestPalindrome(s):
  s = s.lower()
  #Insert special characters, #, between characters
  #Insert another special in the front, $, and at the end, @, of string  to avoid bound checking.
  s1 = '$#'
  for c in s:
      s1 += c + '#'
  s1 = s1+'@'
  #print(s, " -modified into- ", s1)

  #Palin[i] = length of longest palindrome start at center i
  Palin = [0]*len(s1)

  #THE HARD PART: THE MEAT of the ALGO

  #c and r help keeping track of the expanded regions.
  c = r = 0

  for i in range(1,len(s1)-1): #NOTE: this algo always expands around center i

      #if we already expanded past i, we can retrieve partial info 
      #about this location i, by looking at the mirror from left side of center.

      if r > i:  #---nice, we look into memory of the past---
          #look up mirror from left of center c
          mirror = c - (i-c)

          #mirror's largest palindrome = Palin[mirror]

          #case1: if mirror's largest palindrome expands past r, choose r-i
          #case2: if mirror's largest palindrome is contains within r, choose Palin[mirror]
          Palin[i] = min(r-i, Palin[mirror]) 

      #keep expanding around center i
      #NOTE: instead of starting to expand from i-1 and i+1, which is repeated work
      #we start expanding from Palin[i], 
      ##which is, if applicable, updated in previous step
      while s1[i+1+Palin[i]] == s1[i-1-Palin[i]]:
          Palin[i] += 1

      #if expanded past r, update r and c
      if i+Palin[i] > r:
          c = i
          r = i + Palin[i]

  #the easy part: find the max length, remove special characters, and return
  max_center = max_length = 0
  for i in range(len(s1)):
      if Palin[i] > max_length:
          max_length = Palin[i]
          max_center = i  
  output = s1[max_center-max_length : max_center+max_length]
  output = ''.join(output.split('#'))
  return output # for the (the result substring)

using namespace std;

class Palindrome{
public:
    Palindrome(string st){
        s = st; 
        longest = 0; 
        maxDist = 0;
        //ascii: 126(~) - 32 (space) = 94 
        // for 'a' to 'z': vector<vector<int>> v(26,vector<int>(0)); 
        vector<vector<int>> v(94,vector<int>(0)); //all ascii 
        mDist.clear();
        vPos = v; 
        bDebug = true;
    };

    string s;
    string sPrev;    //previous char
    int longest;     //longest palindrome size
    string sLongest; //longest palindrome found so far
    int maxDist;     //max distance been checked 
    bool bDebug;

    void findLongestPal();
    int checkIfAnchor(int iChar, int &i);
    void checkDist(int iChar, int i);

    //store char positions in s pos[0] : 'a'... pos[25] : 'z' 
    //       0123456
    // i.e. "axzebca" vPos[0][0]=0  (1st. position of 'a'), vPos[0][1]=6 (2nd pos. of 'a'), 
    //                vPos[25][0]=2 (1st. pos. of 'z').  
    vector<vector<int>> vPos;

    //<anchor,distance to check> 
    //   i.e.  abccba  anchor = 3: position of 2nd 'c', dist = 3 
    //   looking if next char has a dist. of 3 from previous one 
    //   i.e.  abcxcba anchor = 4: position of 2nd 'c', dist = 4 
    map<int,int> mDist;
};

//check if current char can be an anchor, if so return next distance to check (3 or 4)
// i.e. "abcdc" 2nd 'c' is anchor for sub-palindrome "cdc" distance = 4 if next char is 'b'
//      "abcdd: 2nd 'd' is anchor for sub-palindrome "dd"  distance = 3 if next char is 'c'
int Palindrome::checkIfAnchor(int iChar, int &i){
    if (bDebug)
          cout<<"checkIfAnchor. i:"<<i<<" iChar:"<<iChar<<endl;
    int n = s.size();
    int iDist = 3;
    int iSize = vPos[iChar].size();
    //if empty or distance to closest same char > 2
    if ( iSize == 0 || vPos[iChar][iSize - 1] < (i - 2)){
        if (bDebug)
              cout<<"       .This cannot be an anchor! i:"<<i<<" : iChar:"<<iChar<<endl; 
        //store char position
        vPos[iChar].push_back(i);
        return -1; 
    }

    //store char position of anchor for case "cdc"
    vPos[iChar].push_back(i);    
    if (vPos[iChar][iSize - 1] == (i - 2))
        iDist = 4;
    //for case "dd" check if there are more repeated chars
    else {
        int iRepeated = 0;
        while ((i+1) < n && s[i+1] == s[i]){
            i++;
            iRepeated++;
            iDist++; 
            //store char position
            vPos[iChar].push_back(i);
        }
    }

    if (bDebug)
          cout<<"       .iDist:"<<iDist<<" i:"<<i<<endl; 

    return iDist;
};

//check distance from previous same char, and update sLongest
void Palindrome::checkDist(int iChar, int i){
    if (bDebug)
            cout<<"CheckDist. i:"<<i<<" iChar:"<<iChar<<endl;
    int iDist;
    int iSize = vPos[iChar].size();
    bool b1stOrLastCharInString; 
    bool bDiffDist;

    //checkAnchor will add this char position 
    if ( iSize == 0){
        if (bDebug)
            cout<<"       .1st time we see this char. Assign it INT_MAX Dist"<<endl; 
        iDist = INT_MAX;
    }
    else {
        iDist = i - vPos[iChar][iSize - 1]; 
    }

    //check for distances being check, update them if found or calculate lengths if not.
    if (mDist.size() == 0) {
        if (bDebug)
             cout<<"       .no distances to check are registered, yet"<<endl;
        return;
    }

    int i2ndMaxDist = 0;
    for(auto it = mDist.begin(); it != mDist.end();){
        if (bDebug)
                cout<<"       .mDist. anchor:"<<it->first<<" . dist:"<<it->second<<endl; 
        b1stOrLastCharInString = false; 
        bDiffDist = it->second == iDist;  //check here, because it can be updated in 1st. if
        if (bDiffDist){
            if (bDebug)
                cout<<"       .Distance checked! :"<<iDist<<endl;
            //check if it's the first char in the string
            if (vPos[iChar][iSize - 1] == 0 || i == (s.size() - 1))
                b1stOrLastCharInString = true;
            //we will continue checking for more...
            else {
                it->second += 2; //update next distance to check
                if (it->second > maxDist) {
                     if (bDebug)
                          cout<<"       .previous MaxDist:"<<maxDist<<endl;
                     maxDist = it->second;
                     if (bDebug)
                          cout<<"       .new MaxDist:"<<maxDist<<endl;
                }
                else if (it->second > i2ndMaxDist) {//check this...hmtest
                     i2ndMaxDist = it->second;
                     if (bDebug)
                          cout<<"       .second MaxDist:"<<i2ndMaxDist<<endl;
                }
                it++; 
            }
        }
        if (!bDiffDist || b1stOrLastCharInString) {
            if (bDebug && it->second != iDist)
                cout<<"       .Dist diff. Anchor:"<<it->first<<" dist:"<<it->second<<" iDist:"<<iDist<<endl;
            else if (bDebug) 
                cout<<"       .Palindrome found at the beggining or end of the string"<<endl;

            //if we find a closest same char.
            if (!b1stOrLastCharInString && it->second > iDist){
                if (iSize > 1) {
                   if (bDebug)
                       cout<<"       . < Dist . looking further..."<<endl; 
                   iSize--;  
                   iDist = i - vPos[iChar][iSize - 1];
                   continue;    
                }
            }
            if (iDist == maxDist) {
                maxDist = 0;
                if (bDebug)
                     cout<<"       .Diff. clearing Max Dist"<<endl;
            }
            else if (iDist == i2ndMaxDist) {
                i2ndMaxDist = 0;
                if (bDebug)
                      cout<<"       .clearing 2nd Max Dist"<<endl; 
            }

            int iStart; 
            int iCurrLength;
            //first char in string
            if ( b1stOrLastCharInString && vPos[iChar].size() > 0 && vPos[iChar][iSize - 1] == 0){
                iStart = 0;
                iCurrLength = i+1;
            }
            //last char in string
            else if (b1stOrLastCharInString && i == (s.size() - 1)){
                iStart = i - it->second; 
                iCurrLength = it->second + 1;
            }
            else {
                iStart = i - it->second + 1; 
                iCurrLength = it->second - 1;  //"xabay" anchor:2nd. 'a'. Dist from 'y' to 'x':4. length 'aba':3
            }

            if (iCurrLength > longest){
                if (bDebug)
                      cout<<"       .previous Longest!:"<<sLongest<<" length:"<<longest<<endl;
                longest = iCurrLength;               
                sLongest = s.substr(iStart, iCurrLength);

                if (bDebug)
                      cout<<"       .new Longest!:"<<sLongest<<" length:"<<longest<<endl;
            }

            if (bDebug)
                  cout<<"       .deleting iterator for anchor:"<<it->first<<" dist:"<<it->second<<endl; 

            mDist.erase(it++);
        }
    }


    //check if we need to get new max distance
    if (maxDist == 0 && mDist.size() > 0){ 
        if (bDebug)
              cout<<"       .new maxDist needed";
        if (i2ndMaxDist > 0) {
            maxDist = i2ndMaxDist;
            if (bDebug)
              cout<<"       .assigned 2nd. max Dist to max Dist"<<endl;
        }
        else {
            for(auto it = mDist.begin(); it != mDist.end(); it++){
                if (it->second > maxDist)
                    maxDist = it->second;
            }
            if (bDebug)
              cout<<"       .new max dist assigned:"<<maxDist<<endl;
        }
    }  
};        

void Palindrome::findLongestPal(){
    int n = s.length(); 
    if (bDebug){
        cout<<"01234567891123456789212345"<<endl<<"abcdefghijklmnopqrstuvwxyz"<<endl<<endl;            
        for (int i = 0; i < n;i++){
            if (i%10 == 0)
                cout<<i/10;
            else
                cout<<i;
        }
        cout<<endl<<s<<endl;
    }
    if (n == 0)
        return;

    //process 1st char
    int j = 0;
    //for 'a' to 'z' : while (j < n && (s[j] < 'a' && s[j] > 'z'))
    while (j < n && (s[j] < ' ' && s[j] > '~'))
        j++;
    if (j > 0){
        s.substr(j);
        n = s.length();
    }
    // for 'a' to 'z' change size of vector from 94 to 26 : int iChar = s[0] - 'a';
    int iChar = s[0] - ' ';
    //store char position
    vPos[iChar].push_back(0);  

    for (int i = 1; i < n; i++){
        if (bDebug)
            cout<<"findLongestPal. i:"<<i<<" "<<s.substr(0,i+1)<<endl; 
        //if max. possible palindrome would be smaller or equal 
        //             than largest palindrome found then exit
        //   (n - i) = string length to check 
        //   maxDist: max distance to check from i 
        int iPossibleLongestSize = maxDist + (2 * (n - i));
        if ( iPossibleLongestSize <= longest){
            if (bDebug)
                cout<<"       .PosSize:"<<iPossibleLongestSize<<" longest found:"<<iPossibleLongestSize<<endl;
            return;
        }

        //for 'a' to 'z' : int iChar = s[i] - 'a';
        int iChar = s[i] - ' ';
        //for 'a' to 'z': if (iChar < 0 || iChar > 25){
        if (iChar < 0 || iChar > 94){
            if (bDebug)
                cout<<"       . i:"<<i<<" iChar:"<<s[i]<<" skipped!"<<endl;
            continue;
        }

        //check distance to previous char, if exist
        checkDist(iChar, i);

        //check if this can be an anchor
        int iDist = checkIfAnchor(iChar,i);
        if (iDist == -1) 
            continue;

        //append distance to check for next char.
        if (bDebug)
                cout<<"       . Adding anchor for i:"<<i<<" dist:"<<iDist<<endl;
        mDist.insert(make_pair(i,iDist));

        //check if this is the only palindrome, at the end
        //i.e. "......baa" or "....baca" 
        if (i == (s.length() - 1) && s.length() > (iDist - 2)){
            //if this is the longest palindrome! 
            if (longest < (iDist - 1)){
                sLongest = s.substr((i - iDist + 2),(iDist - 1));
            }
        }
    }
};

int main(){
    string s;
    cin >> s;

    Palindrome p(s);
    p.findLongestPal();
    cout<<p.sLongest; 
    return 0;
}