题目

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

示例 1：

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

示例 2：

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

题解

摘要

这篇文章是为中级读者而写的。它介绍了回文，动态规划以及字符串处理。请确保你理解什么是回文。回文是一个正读和反读都相同的字符串，例如，“aba” 是回文，而 “abc” 不是。

解决方案

方法一：最长公共子串

常见错误

有些人会忍不住提出一个快速的解决方案，不幸的是，这个解决方案有缺陷(但是可以很容易地纠正)：

反转 SS，使之变成 S’S′。找到 SS 和 S’S′ 之间最长的公共子串，这也必然是最长的回文子串。

这似乎是可行的，让我们看看下面的一些例子。

例如，S*=“caba” , S′=“abac”：

SS 以及 S’S′ 之间的最长公共子串为“aba”，恰恰是答案。

让我们尝试一下这个例子：S*=“abacdfgdcaba” , S′=“abacdgfdcaba”：

SS 以及 S’S′ 之间的最长公共子串为 “abacd”，显然，这不是回文。

算法

我们可以看到，当 SS 的其他部分中存在非回文子串的反向副本时，最长公共子串法就会失败。为了纠正这一点，每当我们找到最长的公共子串的候选项时，都需要检查子串的索引是否与反向子串的原始索引相同。如果相同，那么我们尝试更新目前为止找到的最长回文子串；如果不是，我们就跳过这个候选项并继续寻找下一个候选。

这给我们提供了一个复杂度为 O(n²)动态规划解法，它将占用 O(n²)的空间（可以改进为使用 O(n) 的空间）。请在这里阅读更多关于最长公共子串的内容。

方法二：暴力法

很明显，暴力法将选出所有子字符串可能的开始和结束位置，并检验它是不是回文。

复杂度分析

时间复杂度：O(n³)，假设 n 是输入字符串的长度，则 $\binom{n}{2} = \frac{n(n-1)}{2} $ 为此类子字符串(不包括字符本身是回文的一般解法)的总数。因为验证每个子字符串需要 O(n) 的时间，所以运行时间复杂度是 $O(n^3)$ 。
空间复杂度：O(1)。

方法三：动态规划

为了改进暴力法，我们首先观察如何避免在验证回文时进行不必要的重复计算。考虑 “ababa” 这个示例。如果我们已经知道 “bab” 是回文，那么很明显，“ababa” 一定是回文，因为它的左首字母和右尾字母是相同的。

我们给出 P(i,j)的定义如下：

$ P(i,j) = \begin{cases} \text{true,} &\quad\text{如果子串} S_i \dots S_j \text{是回文子串}\ \text{false,} &\quad\text{其它情况} \end{cases} $*

因此，

$ P(i, j) = ( P(i+1, j-1) \text{ and } S_i == S_j )$

基本示例如下：

P(i, i) = true

$ P(i, i+1) = ( S_i == S_{i+1} )$

这产生了一个直观的动态规划解法，我们首先初始化一字母和二字母的回文，然后找到所有三字母回文，并依此类推…

复杂度分析

时间复杂度：O(n²)，这里给出我们的运行时间复杂度为 O(n²) 。
空间复杂度：O(n²)，该方法使用 O(n²) 的空间来存储表。

补充练习

你能进一步优化上述解法的空间复杂度吗？

方法四：中心扩展算法

事实上，只需使用恒定的空间，我们就可以在 O(n²) 的时间内解决这个问题。

我们观察到回文中心的两侧互为镜像。因此，回文可以从它的中心展开，并且只有 2n - 1 个这样的中心。

你可能会问，为什么会是 2n - 1个，而不是 n个中心？原因在于所含字母数为偶数的回文的中心可以处于两字母之间（例如“abba” 的中心在两个 ‘b’ 之间）。

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²)，由于围绕中心来扩展回文会耗去 O(n)的时间，所以总的复杂度为 O(n²)。
空间复杂度：O(1)。

方法五：Manacher 算法

还有一个复杂度为 O(n) 的 Manacher 算法，你可以在这里找到详尽的解释。然而，这是一个非同寻常的算法，在45分钟的编码时间内提出这个算法将会是一个不折不扣的挑战。但是，请继续阅读并理解它，我保证这将是非常有趣的。

感想

方法五的马拉车算法在这里介绍一下：(引用自Manacher算法-经典算法与数据结构 )

参考这个自己写出的题解在这个：

class Solution {
    public String longestPalindrome(String s) {
        String str = InsertSharpToString(s);
        String output = Manacher(str);
        return output;
    }
    //构造插入了'#'的以'$'开头的新字符串
    private String InsertSharpToString(String aS){
    	StringBuilder sb= new StringBuilder();
        sb.append('$');
        for(int i =0;i<aS.length();i++){
            sb.append('#');
            sb.append(aS.charAt(i));
        }
        sb.append('#');
        String str = sb.toString();
        return str;
    }
    //马拉车算法，复杂度O(n)
    private String Manacher(String aStr){
    	int len = aStr.length();
    	int[] p=new int[len];//辅助数组，p[i]存储以i为中心的最长回文的半径
    	int mx=0;//代表以id为中心回文的右边界,mx=id+p[id]
    	int id=-1;//id必须赋个初值，java方法局部变量不初始化的话无法使用。
    	int max_len = -1;
    	int max=-1;
    	for(int i=1;i<len;i++){
    		if(i<mx) p[i]= (p[2*id-i]>mx-i)?mx-i:p[2*id-i];//p[i]取p[2*id-i]和mx-i的最小值。2*id-i是i关于id的对称点。
    		else p[i]=1;
    		while(i+p[i]<len && aStr.charAt(i-p[i])==aStr.charAt(i+p[i]))/*需要边界判断，因为java String结尾没有'\0' */
    			p[i]++;
    		// 我们每走一步 i，都要和 mx 比较，我们希望 mx 尽可能的远，这样才能更有机会执行 if (i < mx)这句代码，从而提高效率
    		if(mx<i+p[i]){
    			id=i;
    			mx=i+p[i];
    		}
    		if(max_len<p[i]-1){
    			max_len=p[i]-1;
    			max=i;
    		}
    	}
    	StringBuilder sb= new StringBuilder();
    	for(int i=max-p[max]+1;i<max+p[max];i++){
    		if (aStr.charAt(i)!='#') {
    			sb.append(aStr.charAt(i));
    		}
    	}
    	return (sb.toString());
    }
}

一：背景

给定一个字符串，求出其最长回文子串。例如：

s=“abcd”，最长回文长度为 1；
s=“ababa”，最长回文长度为 5；
s=“abccb”，最长回文长度为 4，即bccb。

以上问题的传统思路大概是，遍历每一个字符，以该字符为中心向两边查找。其时间复杂度为 $O(n^2)$ ，效率很差。

1975年，一个叫Manacher的人发明了一个算法，Manacher算法（中文名：马拉车算法），该算法可以把时间复杂度提升到 $O(n)$ 。

二：算法过程分析

由于回文分为偶回文（比如 bccb）和奇回文（比如 bcacb），而在处理奇偶问题上会比较繁琐，所以这里我们使用一个技巧，具体做法是：在字符串首尾，及各字符间各插入一个字符（前提这个字符未出现在串里）。

举个例子：s="abbahopxpo"，转换为s_new="$#a#b#b#a#h#o#p#x#p#o#"（这里的字符 $ 只是为了防止越界，下面代码会有说明），如此，s 里起初有一个偶回文abba和一个奇回文opxpo，被转换为#a#b#b#a#和#o#p#x#p#o#，长度都转换成了奇数。

定义一个辅助数组int p[]，其中p[i]表示以 i 为中心的最长回文的半径，例如：

i	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16	17	18	19
s_new[i]	$	#	a	#	b	#	b	#	a	#	h	#	o	#	p	#	x	#	p	#
p[i]		1	2	1	2	5	2	1	2	1	2	1	2	1	2	1	4	1	2	1

可以看出，p[i] - 1正好是原字符串中最长回文串的长度。

接下来的重点就是求解 p 数组:

设置两个变量，mx 和 id 。mx 代表以 id 为中心的最长回文的右边界，也就是mx = id + p[id]。

假设我们现在求p[i]，也就是以 i 为中心的最长回文半径，如果i < mx，如上图，那么：

if (i < mx)  
    p[i] = min(p[2 * id - i], mx - i);

2 * id - i为 i 关于 id 的对称点，即上图的 j 点，而p[j]表示以 j 为中心的最长回文半径，因此我们可以利用p[j]来加快查找。

三：代码

C++代码如下：

#include <iostream>  
#include <cstring>
#include <algorithm>  

using namespace std;

char s[1000];
char s_new[2000];
int p[2000];

int Init()
{
    int len = strlen(s);
    s_new[0] = '$';
    s_new[1] = '#';
    int j = 2;

    for (int i = 0; i < len; i++)
    {
        s_new[j++] = s[i];
        s_new[j++] = '#';
    }

    s_new[j] = '\0';  // 别忘了哦
    
    return j;  // 返回 s_new 的长度
}

int Manacher()
{
    int len = Init();  // 取得新字符串长度并完成向 s_new 的转换
    int max_len = -1;  // 最长回文长度

    int id;
    int mx = 0;

    for (int i = 1; i < len; i++)
    {
        if (i < mx)
            p[i] = min(p[2 * id - i], mx - i);  // 需搞清楚上面那张图含义, mx 和 2*id-i 的含义
        else
            p[i] = 1;

        while (s_new[i - p[i]] == s_new[i + p[i]])  // 不需边界判断，因为左有'$',右有'\0'
            p[i]++;

        // 我们每走一步 i，都要和 mx 比较，我们希望 mx 尽可能的远，这样才能更有机会执行 if (i < mx)这句代码，从而提高效率
        if (mx < i + p[i])
        {
            id = i;
            mx = i + p[i];
        }

        max_len = max(max_len, p[i] - 1);
    }

    return max_len;
}

int main()
{
    while (printf("请输入字符串：\n"))
    {
        scanf("%s", s);
        printf("最长回文长度为 %d\n\n", Manacher());
    }
    return 0;
}

四：算法复杂度分析

文章开头已经提及，Manacher算法为线性算法，即使最差情况下其时间复杂度亦为 $O(n)$ ，在进行证明之前，我们还需要更加深入地理解上述算法过程。

根据回文的性质，p[i]的值基于以下三种情况得出：

（1）：j 的回文串有一部分在 id 的之外，如下图：

上图中，黑线为 id 的回文，i 与 j 关于 id 对称，红线为 j 的回文。那么根据代码此时p[i] = mx - i，即紫线。那么p[i]还可以更大么？答案是不可能！见下图：

假设右侧新增的紫色部分是p[i]可以增加的部分，那么根据回文的性质，a 等于 d ，也就是说 id 的回文不仅仅是黑线，而是黑线+两条紫线，矛盾，所以假设不成立，故p[i] = mx - i，不可以再增加一分。

（2）：j 回文串全部在 id 的内部，如下图：

根据代码，此时p[i] = p[j]，那么p[i]还可以更大么？答案亦是不可能！见下图：

假设右侧新增的红色部分是p[i]可以增加的部分，那么根据回文的性质，a 等于 b ，也就是说 j 的回文应该再加上 a 和 b ，矛盾，所以假设不成立，故p[i] = p[j]，也不可以再增加一分。

（3）：j 回文串左端正好与 id 的回文串左端重合，见下图：

根据代码，此时p[i] = p[j]或p[i] = mx - i，并且p[i]还可以继续增加，所以需要

while (s_new[i - p[i]] == s_new[i + p[i]]) 
    p[i]++;

根据（1）（2）（3），很容易推出Manacher算法的最坏情况，即为字符串内全是相同字符的时候。在这里我们重点研究Manacher（）中的for语句，推算发现for语句内平均访问每个字符5次，即时间复杂度为： $T_{worst}(n)=O(n)$ 。

同理，我们也很容易知道最佳情况下的时间复杂度，即字符串内字符各不相同的时候。推算得平均访问每个字符4次，即时间复杂度为： $T_{best}(n)=O(n)$ 。

综上，Manacher算法的时间复杂度为 $O(n)$ 。

【力扣算法】5-最长回文子串

题目

题解

摘要

解决方案

方法一：最长公共子串

方法二：暴力法

方法三：动态规划

方法四：中心扩展算法

方法五：Manacher 算法

感想

一：背景

二：算法过程分析

三：代码

四：算法复杂度分析

猜你喜欢