leecode 5. Longest Palindromic Substring

这个题目刚开始的想法是用暴力方法求解，结果超时了，很气，就已经成功完成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.csdn.net/dyx404514/article/details/42061017