leecode 5. Longest Palindromic Substring

最新推荐文章于 2025-07-16 16:59:19 发布

原创最新推荐文章于 2025-07-16 16:59:19 发布 · 177 阅读

0 ·

CC 4.0 BY-SA版权

c++ 同时被 2 个专栏收录

41 篇文章

订阅专栏

leetcode刷题

26 篇文章

订阅专栏

本文探讨了寻找字符串中最长回文子串的有效算法。首先介绍了暴力求解的方法及其时间复杂度过高的问题，随后深入解析了使用动态规划解决此问题的高效方案，并给出了具体实现代码。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

这个题目刚开始的想法是用暴力方法求解，结果超时了，很气，就已经成功完成92个用例了，就差一个了。代码如下（这种方法是最耗时间的，时间复杂度是O（n^3））：

class Solution {
public:
    string longestPalindrome(string s) {
        int start=0,maxlength=1;
        int length=s.size();
        for(int i=0;i<length-1;i++)
        {
            if(maxlength>=length-i)
                break;
            for(int j=i+1;j<length;j++)
            {
                if(ispalindromic(s,i,j))
                {
                    if(j-i+1>maxlength)
                    {
                        maxlength=j-i+1; start=i;
                    }    
                }
            }
        }
        return s.substr(start,maxlength);
    }
    bool ispalindromic(string s,int start,int end)
    {
        while(start<=end)
        {
            if(s[start]==s[end])
            {
                start++;end--;
            }
            else
            {
                return false;
            }
        }
        return true;
    }
};

还有第二种就是用动态规划的二维数组来实现，

我们维护一个二维数组dp，其中dp[i][j]表示字符串区间[i, j]是否为回文串，当i = j时，只有一个字符，肯定是回文串，如果i = j + 1，说明是相邻字符，此时需要判断s[i]是否等于s[j]，如果i和j不相邻，即i - j >= 2时，除了判断s[i]和s[j]相等之外，dp[j + 1][i - 1]若为真，就是回文串，通过以上分析，可以写出递推式如下：

dp[i, j] = 1 if i == j

= s[i] == s[j] if j = i + 1

= s[i] == s[j] && dp[i + 1][j - 1] if j > i + 1

简单来说就是一个字符串[a,m,n,b,h,j,j,h,b,c],比如判断两个b之间是不是回文串的时候，先要判断h与h之间是不是回文串，因此会用到这个二维数组，相当于这个数组用来记忆。

这种方法的时间复杂度可以降低到O（n^2）。

class Solution {
public:
    string longestPalindrome(string s) {
        if(s.size()<=1)  return s;
        int dp[s.size()][s.size()]={0};
        int start=0,end,maxlen=1,length=s.size();
        for(int i=0;i<length;i++)
        {
            dp[i][i]=1;
            if(i<length-1 && s[i]==s[i+1])
            {
                dp[i][i+1]=1; start=i;maxlen=2;
            }      
        }
        for(int i=length-2;i>=0;i--)
            for(int j=i+2;j<length;j++)
            {
                if(s[i]==s[j] && dp[i+1][j-1]==1)
                {
                     dp[i][j]=1;
                     if(j-i+1>maxlen)
                     {
                         start=i; maxlen=j-i+1;
                     }
                }
            }
        return s.substr(start,maxlen);
    }
};

我画图解释一下：如下图所示红色的与圆圈表示第I个字符到第I个字符是不是回文串，这个肯定是，先把红色的标识为1。同时标识红色的同时可以标识了绿色部分，当然需要同时判断是否s[i]==s[I+1]。然后就是剩下的那些圆圈，因为每一个圆圈都要判断dp[I+1][j-1]因此上面行的更新呢取决于下面行的状态，因此直接从下往上进行循环更新，当然每一行是从左往右还是从右往左更新都是无所谓。。

代码如下：

class Solution {
public:
    string longestPalindrome(string s) {
        if(s.size()<=1)  return s;
        int dp[s.size()][s.size()]={0};
        int start=0,end,maxlen=1,length=s.size();
        for(int i=0;i<length;i++)
        {
            dp[i][i]=1;
            if(i<length-1 && s[i]==s[i+1])
            {
                dp[i][i+1]=1; start=i;maxlen=2;
            }      
        }
        for(int i=length-2;i>=0;i--)
            for(int j=i+2;j<length;j++)
            {
                if(s[i]==s[j] && dp[i+1][j-1]==1)
                {
                     dp[i][j]=1;
                     if(j-i+1>maxlen)
                     {
                         start=i; maxlen=j-i+1;
                     }
                }
            }
        return s.substr(start,maxlen);
    }
};

当然这个题还有O（n）的解法，马拉车算法，链接如下：http://blog.youkuaiyun.com/dyx404514/article/details/42061017