while True:
    try:
        zfc = input().strip()
        n = len(zfc)
        klb = []
        for i in range(1, n + 1):
            loop = 0
            while loop < n:
                a = zfc[loop:loop + i]
                klb.append(a)
                loop += 1
        klb1 = []
        for j in klb:
            for m in j:
                if m == j[-(j.index(m) + 1)]:
                    klb1.append(len(j))
        print(max(klb1))
    except:
        break

别人做的 我加一个注释也可以吧

while True:
try:
s=list(input())
count=0
if len(s)==2:
if s[0]==s[1]:
print(2)
else:
print(0)
else: #长度大于2的列表
for i in range(1,len(s)-1): #如果有一个的左边与右边相等，则把左边下标数字定为start
if s[i]==s[i+1]:
num=0#偶数成对
start=i
end=i+1#右边的字母下标定为end
while start>=0 and end<=(len(s)-1) and s[start]==s[end]:
start-=1 #start下标减一位
end+=1 #右边下标加一位
num+=2#顺便把长度加2
if num>count:#赋值count
count=num
if s[i-1]==s[i+1]:#如果是奇数的
num=1#奇数成对
start=i-1#左边下标为i-1
end=i+1#右边为i+1
while start>=0 and end<=(len(s)-1) and s[start]==s[end]: #end为右边的下标 一定只能为最后一位，并且左边等于右边
start-=1 #左减一
end+=1#右加一
num=num+2#长度加2
if num>count:
count=num#如果长度num大于count 赋值
print(count)
except:
break

while 1 :
    try:
        s = input().strip()
        all_lst = []
        for i in range(len(s)):
            for j in range(i+1,len(s)+1):
                all_lst.append(s[i:j])
        res_lst = []
        for k in all_lst:
            if k[::-1] == k:
                res_lst.append(k)
        print(max(map(len, res_lst)))    
    except:
        break

def longest_echo(s):
    res = 1  # 至少为1
    for i in range(1, len(s)-1):
        hf_odd, hf_even = 1, 1
        try:
            while s[i-hf_odd] == s[i+hf_odd]:  hf_odd += 1
        except:
            pass
        try:
            while s[i-hf_even] == s[i+hf_even-1]:  hf_even += 1
        except:
            pass
        res = max(res, hf_even*2-2, hf_odd*2+1-2) # 条件退出的时候，需要-2（包括超界或不相等）
    return res

import sys
for line in sys.stdin:
    print(longest_echo(line.strip()))

# 改版
def zcHW(s):
    if s == s[::-1]:
        return len(s)
    s = list(s)
    newS = '#' + '#'.join(s) + '#'
    Len = len(newS)
    maxLen = [1] * Len # 默认自身为回文
    for i in range(1,Len):
        # 对于索引i，前面有i个元素，索引为[0:i]，后面有Len-i-1个元素，索引[i+1:Len]
        r = min(i, Len-i-1) # 能够达到的最大半径r
        m = 1 # 假设的初始半径
        while m <= r:
            # 当前元素以半径为准，对左右两侧的元素逐一比对
            if newS[i-m] == newS[i+m]:
                maxLen[i] = m 
                m += 1
            else: # 如果不相等了，跳出while循环，去判断下一个i
                break
    return maxLen

while True:
    try:
        s = input().strip()
        maxLen = zcHW(s)
        print(max(maxLen))
    except:
        break

while True:
    try:
        num = input()
        n = len(num)
        count = 0
        while n >= 1:
            for i in range(len(num)-n+1):
                if num[i:i+n] == num[i:i+n][::-1]:
                    print(n)
                    count += 1
                    break
            if count == 1:
                break
            else: n -= 1
    except:
        break

# -*- coding: utf-8 -*-
# !/usr/bin/python3
# 解题思路：著名的马拉车算法，将时间复杂度从暴力搜索的O(n ^ 2)降低到了O(n)
# 算法大概思路：
# 1.预处理，在字符串的每个字符之间插入特殊字符，将字符串长度统一为奇数
# 2.从0开始遍历处理后的字符串，从当前字符向两边查找字符是否相等，计算回文半径
# 3.每次比较回文右边界和mx的大小，使用mx保存已探明的字符串右边界
# 4.如果遍历到位置i比mx大，那么i位置未知，半径为1，从i + 1和i - 1开始向两边找
# 5.如果遍历到位置i比mx小，说明i在上一次的回文范围之内，那么分两种情况
# 6.情况1：i关于上一次的回文中心对称的位置j，j的回文半径小于 mx - i，那么i的回文半径 >= j的回文半径
# 7.情况2：j的回文半径大于mx - i，那么i的回文半径 >= mx - i
# 8.上述情况1是利用已探寻过得信息计算出i位置的已知信息，避免重复探寻
# 9.上述情况2是mx右侧位置信息未知，但是mx左侧信息已知，比年重复探寻
# 10.正是利用已探寻信息计算出已知信息避免重复探寻，将时间复杂度从2次方降低到了1次方

while True:
    try:
        s = input()
        ls = list(s)
        st = '#' + '#'.join(ls) + '#'
        # print(st)

        # 最长回文子串右边界
        mx = 0
        # 记录最新一次回文子串中心，非最长回文子串中心
        flag = 1
        # 各位置回文子串半径
        dp = [1 for i in range(len(st))]
        # 记录最大st最大回文子串半径
        lr = 0
        for i in range(1, len(st)):
            if i < mx:
                dp[i] = min(mx - i, dp[2 * flag - i])

            while i + dp[i] < len(st) and i - dp[i] >= 0 and st[i + dp[i]] == st[i - dp[i]]:
                dp[i] += 1

            if dp[i] + i > mx:
                mx = dp[i] + i
                flag = i
                lr = max(lr, dp[i])

        # print(st[flag - dp[flag] + 1:flag + dp[flag]])
        print(lr - 1)

    except:
        break

def longestPalindrome(s):
    if s==s[::-1]:return len(s)
    maxLen=0
    for i in range(len(s)):
        if i-maxLen>=1 and s[i-maxLen-1:i+1]==s[i-maxLen-1:i+1][::-1]:
            maxLen+=2
            continue
        if i-maxLen>=0 and s[i-maxLen:i+1]==s[i-maxLen:i+1][::-1]:
            maxLen+=1
    return maxLen
while True:
    try:
        a=input()
        if a:
            print(longestPalindrome(a))

    except:
        break

时间复杂度为O(n)

try:
    while(True):
        s = raw_input()
        MaxOdd = 1
        for i in range(1,len(s)-1):
            j = 0
            while i-j >=0 and i+j <= len(s)-1 and s[i-j] == s[i+j]:
                j += 1
            if j > MaxOdd:
                MaxOdd = j
        MaxEven = 0
        for i in range(1,len(s)-1):
            j = 0
            while i-j>=0 and i+j+1<=len(s)-1 and s[i-j] == s[i+j+1]:
                j += 1
            if j > MaxEven:
                MaxEven = j
        print max(2*MaxOdd-1, 2*MaxEven)
except:
    pass