【leetcode】Longest Palindromic Substring

Longest Palindromic Substring

Given a string S, find the longest palindromic substring in S. You may assume that the maximum length of S is 1000, and there exists one unique longest palindromic substring.

Hide Tags

 String

 

利用DP思想做

dp[i][j]表示了第字符串中，s[i,i+1,……, j]是否是回文

 

可以有以下递推公式：

if(i==j) dp[i][j]=true;

if(i-j=1)dp[i][j]=s[i]==s[j];

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

 

class Solution {
public:
    string longestPalindrome(string s) {
       
        int n=s.length();
         //采用vector会超时
        //vector<vector<bool> > dp(n,vector<bool>(n));
        bool dp[1000][1000]={false};
        int maxDis=-1;
        int start;
        int end;
        int dis;
        for(int i=n-1;i>=0;i--)
        {
            for(int j=i;j<n;j++)
            {
                if(s[i]==s[j])
                {
                    dis=j-i;
                    if(dis==0||dis==1||dp[i+1][j-1]&&dis>1)
                    {
                        dp[i][j]=true;
                        if(dis>maxDis)
                        {
                            maxDis=dis;
                            start=i;
                            end=j;
                        }
                    }
                }
            }
        }
        return s.substr(start,end-start+1);
    }
};

 

 

 

 

一种O(n)的算法：

 

算法的思想就是根据前面串的对称情况，在寻找后面的对称串时，可以跳过不必要的比较

 

先在每两个相邻字符中间插入一个分隔符，当然这个分隔符要在原串中没有出现过。一般可以用‘#’分隔。这样就非常巧妙的将奇数长度回文串与偶数长度回文串统一起来考虑了（见下面的一个例子，回文串长度全为奇数了）

在比较的时候为了防止越界，可以再在字符串左右两边添加"^"和'$'

例如abb

^#a#b#b#$

 

P［id］记录的是以字符str［id］为中心的最长回文串，当以str［id］为第一个字符，这个最长回文串向右延伸了P［id］个字符

 

这里有一个很好的性质，P［id］-1就是该回文子串在原串中的长度（包括‘#’）

 

我们用mx记在i之前的回文串中，延伸至最右端的位置。同时用id这个变量记下取得这个最优mx时的id值。

如果i正好在某个回文串内部，则寻找与他对称的位置的元素的回文串的长度p[j],如果p[j]没有超出改回文串的内部，如下图所示，那么p[i]=p[j]

如果超出了，则取p[i]=mx-i

 

 

class Solution {

public: 
    string longestPalindrome(string s) {
       
        int n=s.length();
        int id=0;
        int right=0;
        int i;
       
        string pre_s;
        pre_s="^#";
        for(int i=0;i<n;i++)
        {
            pre_s=pre_s+s[i]+'#';
        }
        pre_s+='$';
       
       
        int n1=pre_s.length();
       
        vector<int> p(n1);
       
        for(i=1;i<n1-1;i++)
        {
            if(i<right)
            {
                p[i]=min(p[2*id-i],right-i);
            }
            else
            {
                p[i]=1;
            }
           
            while(pre_s[i+p[i]]==pre_s[i-p[i]])
            {
                p[i]++;
            }
           
            if(right<p[i]+i)
            {
                right=p[i]+i;
                id=i;
            }
        }
       
        int index=0;
        int maxLen=0;
        for(i=0;i<n1-1;i++)
        {
            if(p[i]>maxLen)
            {
                maxLen=p[i]-1;
                index=i;
            }
        }
        //注意此处找到原来串的位置
        return s.substr((index-maxLen-1)/2,(maxLen));
       
    }
};