最长回文子串

最新推荐文章于 2022-11-15 08:52:23 发布

weixin_34283445

最新推荐文章于 2022-11-15 08:52:23 发布

阅读量99

点赞数

文章标签：数据结构与算法

原文链接：http://www.cnblogs.com/xiuyangleiasp/p/5070991.html

版权

问题描述

给定一个字符串，求它的最长回文子串的长度。

回文串就是正着读和反着读都一样的字符串。

分析与求解

解法一蛮力法

最容易想到的就是蛮力求解，即求出该字符串的每一个子串，再判断子串是否是回文串，找到最长的那个。其中求出每个子串的时间复杂度为O(n²)，判断是否为回文串的复杂度为O(n)，两者是相乘关系，所以整个算法的时间复杂度为O(n³)。

/*
* 判断str[i...j]是否是回文串
*/
bool isPalindrome(const char *str, int begin, int end)
{
    while (begin <= end)
    {
        if (str[begin] == str[end])
        {
            begin++;
            end--;
        }
        else
            return false;
    }
    return true;
}

/*
*返回字符串str的最长回文子串的长度
*/
int longestPalindrome(const char *str)
{
if (str == NULL)
return 0;
int len = strlen(str);
if (len == 1)
return 1;
int longest = 1;
for (int i = 0; i < len; i++)
    for (int j = i + 1; j < len; j++)
        if (isPalindrome(str, i, j) == true)
            longest = longest < j - i + 1 ? j - i + 1 : longest;
return longest;
}

蛮力法

解法二中心扩展法

假设一个字符串str是回文串，那么它一定是左右对称的，所以该字符串以某个字符str[mid]为中心的前缀和后缀一定是相同的。例如，对于回文串"aba"，以'b'为中心，它的前缀和后缀都是'a'。故，可以枚举字符串的每个字符作为回文串的中心位置，左右扩展得到回文串，然后比较得到最长的长度。

注意：这里需要考虑到一个特殊情况，即存在"YXaaXY"这样长度为偶数的特殊子串，这里可以将"aa"视为'a'。

该算法的时间复杂度为O(n²)。

/*
* 以mid为中心轴的回文子串的长度
*/
int palindrome(const char *str, int mid)
{
    int left = mid - 1, right = mid + 1;
    int len = strlen(str);
    while (str[mid] == str[right])
        right++;
    while (left >= 0 && right < len && str[left] == str[right])
    {
        left--;
        right++;
    }
    return right - left - 1;
}

/*
*返回字符串str的最长回文子串的长度
*/
int longestPalindrome(const char *str)
{
    if (str == NULL) return 0;
    int len = strlen(str);
    if (len == 1)return 1;
    int longest = 1;
    for (int i = 0; i < len; i++)
    {
        int tmp = palindrome(str, i);
        if (tmp < longest)
            longest = tmp;
    }
    return longest;
}

中心扩展法

解法三动态规划

对于字符串str，假设dp[i,j]=1表示str[i...j]是回文子串，那个必定存在dp[i+1,j-1]=1。这样最长回文子串就能分解成一系列子问题，可以利用动态规划求解了。

首先构造状态转移方程

上面的状态转移方程表示，当str[i]=str[j]时，如果str[i+1...j-1]是回文串，则str[i...j]也是回文串；如果str[i+1...j-1]不是回文串，则str[i...j]不是回文串。

初始状态

dp[i][i]=1
dp[i][i+1]=1 if str[i]==str[i+1]

上式的意义是单个字符，两个相同字符都是回文串。

/*
*返回字符串str的最长回文子串的长度
*/
int longestPalindrome(const char *str)
{
    if (str == NULL) return 0;
    int len = strlen(str);
    if (len == 1)return 1;
    int longest = 1;
    int dp[100][100];
    for (int i = 0; i < len; i++)
    {
        dp[i][i] = 1;
        if (str[i] == str[i + 1])
            dp[i][i + 1] = 1;
    }

    for (int i = 0; i < len; i++)
    {
        for (int j = i + 2; j <= len; j++)
        {
            if (str[i] == str[j])
            {
                dp[i][j] = dp[i][j - 1];
                if (dp[i][j] == 1)
                {
                    int tmp = j - i + 1;
                    if (longest < tmp)longest = tmp;
                }
            }
            else dp[i][j] = 0;
        }
    }
    return longest;
}

动态规划

根据代码不难看出，动态规划的时间复杂度也为O(n²)。

解法四 Manacher算法

上面的解法从时间复杂度的角度来说，效率都较低。是否存在更快的算法呢？答案是肯定的，就是Manancher算法。Manancher算法可以在线性时间复杂度内求出一个字符串的最长回文子串，达到理论的下界。下面介绍Manacher算法的原理和步骤。

Manacher算法首先通过在每个字符的两边都插入一个特殊的符号（未在字符串中出现过），将所有可能的回文子串都转换成奇数。例如"aba"的两边都插入字符'#'就变成了"#a#b#a#"。为了更好处理越界问题，可以在字符串的开始和结尾加入另一个特殊字符，例如在"#a#b#a#"的开始和结尾插入字符'%'变成"%#a#b#a#%"。

P数组简介

Manacher算法利用一个辅助数组P[i]表示以字符S[i]为中心的最长回文子串的最右（左）字符到S[i]的距离（包括S[i]）。例如以S[i]为中心的最长回文子串是S[l..r]，则P[i]=r-i+1。

对于字符串"aabba"，插入'#'和'%'两个字符后，变成了S[]="%#a#a#b#b#a#%"，可以得到的P[i]数组为：

P数组有一个性质：P[i]-1是该回文子串在原来字符串中的长度。

证明

由于在转换后得到的字符串S中，所有的回文子串的长度都是奇数，所以对于以S[i]为中心的最长回文子串的长度为2P[i]-1。经过观察可知，S中所有的回文子串，其分隔符的数量一定比其他字符多1，即P[i]个字符，剩下P[i]-1字符来自原字符串，所以该回文串在原字符串中的长度是P[i]-1。

利用这个性质，原问题就转换成求所有的P[i]。

P数组的计算

如何计算P[i]呢？首先从左至右依次计算P[i]，但计算P[i]时，P[j](j<i)已经计算完毕。增加两个辅助变量id和mx，其中id表示最大回文子串中心的位置，mx=id+P[id]，即回文子串的边界。则分为两种情况：

i≤mx

令j=2*id-i，j为i关于id的对称点。

当mx-i>P[i]时，以S[j]为中心的回文子串就包含在以S[id]为中心的回文子串中，由于i和j对称，所以S[i]为中心的回文子串必然被包含在以S[id]为中心的回文子串中，故P[i]=P[j]=P[2*id-i]。如下图所示。

当mx-i≤P[i]，以S[j]为中心的回文子串不一定完全包含在以S[id]为中心的回文子串中，但基于对称性可知，以S[i]和S[j]为中心的回文子串在[2*id-mx,mx]范围内的部分是相同，即下图中的方框部分是相同的。换言之，以S[i]为中心的回文子串向右至少会扩展到mx的位置，从而P[i]≥mx-i。至于mx之后的部分，则需要进一步匹配。

根据上面的推导，可以得出结论：如果i<mx，则P[i]≥min(P[2*id-i],mx-i)。

i>mx

如果i比mx大，则说明对于以S[i]为中心的回文子串还有一部分没有匹配，由于无法对P[i]做更多的假设，只能先令P[i]=1，然后在继续进行相关匹配。

综上所述，P[i]的计算公式为

时间复杂度

由于Manacher算法只有在遇到还未匹配的位置时才进行匹配，已经匹配过的位置不再匹配，所以对于对于字符串S的每一个位置，都只进行一次匹配，所以算法的总体复杂度为O(n)。

int p[100];
void init(const char *str, char *tmp)
{
    tmp[0] = '@';
    int len = strlen(str);
    for (int i = 1; i < 2 * len; i += 2)
    {
        tmp[i] = '#';
        tmp[i + 1] = str[i / 2];
    }
    tmp[2 * len + 1] = '#';
    tmp[2 * len + 2] = '@';
    tmp[2 * len + 3] = 0;
}

//Manacher算法计算过程
int longestPalindrome(const char *str)
{
    int mx = 0, ans = 0, id = 0;
    int len = strlen(str);
    int longest = 0;
    for (int i = 1; i <= len; i++)
    {
        if (mx >= i)
            p[i] = min(p[2 * id - i], mx - i);
        else p[i] = 1;
        while (str[i + p[i]] == str[i - p[i]])
            p[i]++;
        if (p[i] + i > mx)
        {
            mx = p[i] + i;
            id = i;
        }
        longest = max(longest, p[id]);
    }
    return longest - 1;
}

Manacher算法

转载于:https://www.cnblogs.com/xiuyangleiasp/p/5070991.html

weixin_34283445

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
最长回文子串

问题描述给定一个字符串，求它的最长回文子串的长度。回文串就是正着读和反着读都一样的字符串。分析与求解解法一蛮力法最容易想到的就是蛮力求解，即求出该字符串的每一个子串，再判断子串是否是回文串，找到最长的那个。其中求出每个子串的时间复杂度为O(n2)，判断是否为回文串的复杂度为O(n)，两者是相乘关系，所以整个算法的时间复杂度为O(n3)。...
复制链接

扫一扫