leetcode5--. 最长回文子串（动态规划）

动态规划

1，对于对角线，只存在一个字符，故都属于回文字符串。
2，首先判断start和end（s[i]==s[j] ?)
当i=0时，j=1， ‘ab’,首尾不同，故为false.
j=2, ‘aba’, 首尾相同，再去判断内部字符串，（i+1,j-1)是否为回文字符串，（如红线标注所示）
j=3 ,’ a…d’ ,首尾不同，故为false.
j=4, ‘a…a’, 首尾相同，再去判断内部字符串，这样要先知道（i+1,j-1)，故扫描的时候要注意
3，找到所有回文子串， 即true部分，判断其长短，找最大长度，（j-i+1)

string longestPalindrome(string s) {
        int len=s.size();
        if(len==0||len==1)
            return s;
        int start=0;//回文子串的开始位置
        int mlen=1;//回文子串的长度
        vector<vector<int> > res(len,vector<int>(len));
        //初始化对角线
        for(int i=0;i<len;i++){
            res[i][i]=true;
        }
       //从上往下扫描，对角线提前设置完，故列数剩下n-1长度
        for(int j=1;j<len;j++){
            for(int i=0;i<j;i++){
                if(s[i]==s[j]){
                    if(j-i<3){   //如果在首尾相等的字符串前提下，长度小于3，则一定是回文
                        res[i][j]=true;
                    }
                    else
                        res[i][j]=res[i+1][j-1]；//首尾判断完，判断内部字符串
                }
                else
                    res[i][j]=false;
                    //寻找最大长度的字符串
                if(res[i][j]){
                    if(mlen<j-i+1){
                        mlen=j-i+1;
                        start=i;
                    }
                }
            }
        }
        return s.substr(start,mlen);
    }

优化：

    string longestPalindrome(string s) {
        int len = s.size();
        if (len==0||len==1) return s;
        //string result;
        int dp[len][len];
        int  start=0,maxLen = 0;
        //动态规划 dp[i][j]
        for (int j = 0; j < len; j++){
            for (int i=0; i <=j; i++){
                //长度为2,3的情况单独考虑
                dp[i][j] = (j-i<3 || dp[i + 1][j - 1]) && (s[i] == s[j]);
                if (dp[i][j] && (j - i + 1) > maxLen){
                    maxLen = j - i + 1;
                    start = i;
                   
                }
            }
        }
        //result = s.substr(start, maxLen);
        return s.substr(start, maxLen);
    }