字符串回文

以为是动态规划，但是这个版本动态规划时间超过了！！

哎，想想也是，这个循环的次数也太多了，也没有合理利用以前的结果。

class Solution {
public:
    string longestPalindrome(string s) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        int M[1000][1000];
        memset(M,0,sizeof(int)*1000*1000);
        
        //vector<vector<int>> M;
        
        if(s.length()<=1) return s;
        
        string t=s;
        for(int i=0;i<s.length();i++)
        {
            t[i]=s[s.length()-1-i];
        }
        
       // M.resize(s.length());
        for(int i=0;i<s.length();i++)
        {
           // M[i].resize(s.length());
            for(int k=0;k<s.length();k++)
            {
                M[i][k]=(s[i]==t[k]);
            }
        }
        
        bool change=true;
        int maxl=1;
        
        int fl=0;
        
        for(int l=1;l<s.length();l++)
        {
            if(!change) break;
            change=false;
            for(int i=0;i<s.length();i++)
            {
                for(int k=0;k<s.length();k++)
                {
                    if(l+i>=s.length() || l+k>=s.length())
                    {
                        break;
                    }
                    else
                    {
                        if(s[i+l]==t[k+l] && M[i][k]==l)
                        {
                            M[i][k]=l+1;
                            change=true;
                            fl=i;
                        }
                    }
                }
            }
            if(change) maxl=l+1;
        }
        return s.substr(fl,maxl);
    }
};

然后坑爹想到映射，呃，没有动态规划，果然时间又超了

class Solution {
public:
    string longestPalindrome(string s) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        
        if(s.length()<=1) return s;
        
        string t=s;
        for(int i=0;i<s.length();i++)
        {
            t[i]=s[s.length()-1-i];
        }
        
        map<char,vector<int>> mapPos;
        for(int i=0;i<s.length();i++)
        {
            map<char,vector<int>>::iterator it=mapPos.find(s[i]);
            if(it!=mapPos.end())
            {
                continue;
            }
            for(int j=0;j<s.length();j++)
            {
                if(s[i]==t[j])
                mapPos[s[i]].push_back(j);
            }
        }
        
        int maxl=0;
        int left=0;
        
        for(int i=0;i<s.length();i++)
        {
            map<char,vector<int>>::iterator it=mapPos.find(s[i]);
            //if(it!=mapPos.end())
            {
                vector<int> p=it->second;
                for(int j=0;j<p.size();j++)
                {
                    int l=1;
                    for(int k=1;i+k<s.length() && p[j]+k<s.length();k++)
                    {
                        if(s[i+k]==t[p[j]+k])
                        {
                            l++;
                        }
                        else
                        {
                            break;
                        }
                    }
                    
                    if(l>maxl)
                    {
                        maxl=l;
                        left=i;
                    }
                }
            }
        }
        return s.substr(left,maxl);
    }
};