leetcode 5. Longest Palindromic Substring

此题是求最长回文子串
思路一：设置头指针，从前往后遍历字符串，设置尾指针，若头尾之间存在回文串，继续下一个位置，否则尾指针向前退一步继续查找。在找到回文串的时候，都要和当前保存的回文串进行比较，始终保存最长的回文串标记。
时间复杂度是O(n^3)

class Solution {
public:
    bool valid(const string & s,int begin,int end)
    {
        while(begin<=end)
        {
            if(s[begin]==s[end])
            {
                begin++;
                end--;
            }
            else
                return false;
        }
        return true;
    }
    string longestPalindrome(string s) {
        string result;
        int begin,end;
        int mlen=INT_MIN;
        int start=0;
        int len=0;
        for(int i=0;i<s.size();i++)
        {
            begin=i;
            end=s.size()-1;
            while(begin<=end)
            {
                if(valid(s,begin,end))
                {
                    if(end-begin+1>mlen)
                    {
                        mlen=end-begin+1;
                        start=begin,
                        len=end-begin+1;
                        break;
                    }
                        
                }
                                   
                end--;
            }
            if(mlen==s.size()-i)   //如果当前头指针后面的字符串就是回文串，及时退出
                break;
        }
        if(len>0)
            result=s.substr(start,len);
        return result;
    }
};

思路二：
利用动态规划思想，dp[i,j]表示从i到j的字符串，如果是1，表示该字符串是回文串，否则不是。
转移状态方程为

dp[i,j]=dp[i+1,j-1] 如果str[i]=str[j]
dp[i,j]=0 如果str[i]与str[j]不相等

初始状态为

dp[i,i]=1
dp[i][i+1]=1 如果str[i]=str[i+1]

时间复杂度为O(n^2)
代码如下：

class Solution {
public:
    string longestPalindrome(string s) {
        string result;
        int slen=s.size();
        if(slen==0)
            return result;
        
        int mlen=INT_MIN;
        int start=0;
        vector<vector<int >> dp(slen,vector<int >(slen,0));
        //初始化
        for(int i=0;i<slen;i++)
        {
            dp[i][i]=1;
            if(1>mlen)
            {
                mlen=1;
                start=i;
            }
                
            if(i+1<slen&&s[i]==s[i+1])
            {
                dp[i][i+1]=1;
                mlen=2;
                start=i;
            }
                
        }
        
        //填表
        for(int len=3;len<=slen;len++)
            for(int i=0;i+len-1<slen;i++)          
            {
                int j=i+len-1;
                if(s[i]==s[j])
                {                   
                    dp[i][j]=dp[i+1][j-1];
                    if(dp[i][j]==1&&len>mlen)
                    {
                        mlen=len;
                        start=i;
                    }
                }
                       
            }
        
        if(mlen>0)
            result=s.substr(start,mlen);
        
        return result;
        
    }
};