[算法] 最长回文串

最长子回文串

思路一

使用动态规划来处理这样的题目，令一个二维表格\(dp\)记录结果，其中\(dp[i][j]\)记录的字符串中区间\([i,j]\)之间的最大回文串的长度，这样我们可以发现初始值：\(dp[i][i]=1\)，且在\(i>j\)的情况下均为0，同时，有如下转移公式：

\[\begin{align} &s[i]=[j]: dp[i][j]=dp[i+1][j-1]+2\\ &s[j]\neq s[j]:dp[i][j]=max(dp[i+1][j],dp[i][j-1]) \end{align} \]

于是可以写出如下代码：

def method1(s: str) -> int:
    # 第一种思路，动态规划，记录dp[i][j]记录[i，j]之间的最大回文串，i==j时：1,i>j时：0
    # 判断s[i]==s[j]则，dp[i][j]=dp[i+1][j-1]+2,否则dp[i][j]=max(dp[i+1][j],dp[i][j-1])
    # 由此，需要确定，i倒着遍历，j正着遍历
    n = len(s)
    dp = [[0] * n for _ in range(n)]
    for i in range(n):
        dp[i][i] = 1
    i = n - 1
    while i >= 0:
        for j in range(i + 1, n):
            if s[i] == s[j]:
                dp[i][j] = dp[i + 1][j - 1] + 2
            else:
                # 这里解释一下索引，i+1一定小于等于j小于n，j-1一定大于等于i大于0
                dp[i][j] = max(dp[i + 1][j], dp[i][j - 1])
        i -= 1
    return dp[0][n - 1]

上述方法时间复杂度为\(o(n^2)\)，空间复杂度为\(o(n^2)\)。

考虑优化一下空间，仔细观察转移公式，可以发现迭代过程中，是从最后一行向上迭代，并且迭代每一行的时候，仅依赖于下一行，于是可以考虑使用单独的一个数组来替代整个的二位数组，有如下代码：

def method2(self, s: str) -> int:
    # 优化一下空间，仅采用两个向量来记录结果动态规划结果
    n = len(s)
    dp = [0] * n
    for i in range(n - 1, -1, -1):
        tem_dp = [0] * n
        tem_dp[i] = 1
        for j in range(i + 1, n):
            if s[i] == s[j]:
                tem_dp[j] = dp[j - 1] + 2
            else:
                tem_dp[j] = max(dp[j], tem_dp[j - 1])
        dp = tem_dp
    return dp[n - 1]

和方法一唯一的不同点在于，仅记录了原本二维数组中最新的一行的数据，于是，在时间复杂度不变的情况下，空间复杂度优化到了\(o(n)\)；

思路二

将字符串做一个反转后，求两个字符串的最大子序列，这样就等价于求最长回文序列；

字符串没有必要实际的进行反转，仅在遍历过程中选取对应的字符即可；

代码如下：

def method3(self, s: str) -> int:
    # 另一个思路，将字符串反转，然后求解两个串的最长子序列
    n = len(s)
    dp = [[0] * (n + 1) for _ in range(n + 1)]
    for i in range(1, n + 1):
        for j in range(1, n + 1):
            if s[- j] == s[i - 1]:
                dp[i][j] = dp[i - 1][j - 1] + 1
            else:
                dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])
    return dp[n][n]

求解最长公共子序列是个经典问题，依旧是采用的动态规划的思路求解，\(dp[i][j]\)记录的是两个字符串的字串\([0:i+1]\)和\([0:j+1]\)的最长字串长度；

算法的时间复杂度是\(o(n^2)\)，空间复杂度也是\(o(n^2)\)，但是由于这里遍历的时候要将整个二维数组全部更新一遍，二思路一则仅仅更新了一半的矩阵，因此实际运行时，思路1是要比这个思路快的；

同样的，从转移方程可以看出，更新新一行数据时仅依赖上一行的数据，于是我们可以优化下空间复杂度到\(o(n)\)，代码如下：

def method4(self, s: str) -> int:
    # 顺着求最大字串的思路，优化一下空间
    n = len(s)
    dp = [0] * n
    for i in range(0, n):
        temp = [0] * n
        for j in range(0, n):
            if s[n - j - 1] == s[i]:
                temp[j] = dp[j - 1] + 1 if j > 0 else 1
            else:
                temp[j] = max(dp[j], temp[j - 1] if j > 0 else 0)
        dp = temp
    return dp[n - 1]