LeetCode OJ(5)

Longest Palindromic Substring

最长回文子序列，经典的DP问题

最开始我的想法是（偏递归的实现方法）：
对于一个范围为[i,j]的字符串，先判断s[i]和s[j]是否相等：
（1）如果s[i]=s[j]，则最长回文字串可能为整个字符串，此时，需要判断[i+1,j-1]字符串的最长回文子序列是否为其本身；
（2）如果s[i]!=s[j]，则最长回文字串为s[i,j-1]和s[i+1,j]的回文子序列之一，于是判断两者的长度；

算法实现略（LeetCode不保留之前提交的代码这点略坑啊），递归的方法最后Time Limit Exceeded~

之后，为了改进，想着把原有的[i,j-1]和[i+1,j]改为[i’,j’]，但是首尾一致的情况；最后改成如下的代码：

N^2的扫描算法

string longestPalindrome(string s) {
    int len=s.length();
    int start=0;
    int end=len-1;
    string sub;
    string result=NULL;
    while(start<len){
        while(s[start]!=s[end]) end--;
        if(start==end || end==start+1){
            return s.substr(start,end-start+1);
        }
        sub=s.substr(start+1,end-start-1);
        string sub_long=longestPalindrome(sub);
        if(sub_long==sub)
            return s.substr(start,end-start+1);
        else
            return sub_long;
        start++;
    }
    return NULL;
}

可是，谁能告诉我，到底为嘛一直提示：runtime error！而且，last executed input竟然是”a”！完全不能理解！求大神指点迷经啊！

最后（最终），在看了部分答案的提醒下，DP经典算法，终于AC了，不容易啊！相当的不容易！

鄙渣的代码如下所示：

string longestPalindrome(string s) {
    int len=s.length();
    bool palstr[len][len];
    int interval=0;
    int start=0;
    int end=0;
    while(interval<len){
        for(int i=0;i<len-interval;i++){
            int j=i+interval;
            if(interval<=1){
                if(s[i]==s[j]){
                    palstr[i][j]=true;
                    start=i;
                    end=j;
                }
                else
                    palstr[i][j]=false;
            }
            else{
                if(s[i]==s[j]){
                    if(palstr[i+1][j-1]){
                        palstr[i][j]=true;
                        start=i;
                        end=j;
                    }
                    else
                        palstr[i][j]=false;
                }
                else{
                    palstr[i][j]=false;
                }
            }
        }
        interval++;
    }
    return s.substr(start,end-start+1);
}