给定一个字符串 s，返回 s 中最长的回文子字符串。如果字符串的相反顺序与原始字符串相同，则字符串称为回文。（1<=s.length（）<=50 且 s 仅包含字母和数字）

可以使用动态规划来解决这个问题。我们可以定义一个二维数组 dp，其中 dp[i][j] 表示从 i 到 j 是否是回文子串。则有：

1. dp[i][i] = true，单个字符本身就是回文串；

2. dp[i][j] = (s[i] == s[j]) && dp[i+1][j-1]，如果 s[i] 等于 s[j] 且 s[i+1] 到 s[j-1] 是回文子串，则 s[i] 到 s[j] 也是回文子串。

根据上述定义，我们可以使用两层循环遍历字符串 s，记录最长回文子串的开始位置和长度，最终返回最长回文子串即可。代码如下：

def longestPalindrome(s: str) -> str:
    n = len(s)
    if n < 2:
        return s
    dp = [[False] * n for _ in range(n)]
    start, max_len = 0, 1
    for i in range(n):
        dp[i][i] = True
    for j in range(1, n):
        for i in range(j):
            if s[i] == s[j]:
                if j - i < 3:
                    dp[i][j] = True
                else:
                    dp[i][j] = dp[i+1][j-1]
            else:
                dp[i][j] = False
            if dp[i][j]:
                cur_len = j - i + 1
                if cur_len > max_len:
                    max_len = cur_len
                    start = i
    return s[start:start+max_len]

这个算法的时间复杂度是 $O(n^2)$，空间复杂度也是 $O(n^2)$。