Leetcode el más largo palindrómica subcadena

título Descripción

Dada una cadena s, s para encontrar la más larga palindrómica subcadena. Se puede suponer que la longitud máxima de 1000 s.

pensamiento

1. Violencia Solución: El flip obtenido rev s, s desde el principio en el rev elementos coinciden, un partido se verifica desde la posición inicial para que coincida o no coinciden hasta llegar al final de la cadena, la cadena se corresponde segmento, este tiempo es necesario para determinar la cadena de si una cadena es un palíndromo, si el registro, si no, entonces saltar. Obviamente, este método tiene la complejidad O (n ^ 3), parte del caso de tiempo de espera voluntad
2. La programación dinámica, el establecimiento de una matriz para describir si j es una cadena palíndromo de la cadena de i a un lugar, si se compara con 1, 0 de otro modo, hay que señalar que si i a j secuencia palíndromo, primera necesidad de i y j del mismo carácter, seguido por la distancia requerida j y i es menor que 3 o i + 1 para j-1 es una secuencia palindrómica. Si subseries palindrómicas de inicio y la duración, se toma registró la salida final. referencia específica
3. método de difusión en el centro , con especial referencia a

código

Solución uno:

class Solution {
public:
    string longestPalindrome(string s) {
        if(s.length()==1) return s;
        string rev = s;
        string res;
        reverse(rev.begin(),rev.end());
        int max_len = 0;
        for(int i = 0; i <s.length();i++)
        {
            for(int j = 0;j < rev.length();j++)
            {
                if(s[i] == rev[j])
                {
                    string tmp;
                    int k = i;
                    int m = j;
                    while(s[k] == rev[m] && k < s.length() && m < s.length())
                    {
                        tmp = tmp + s[k];
                        k++;
                        m++;
                    }
                    string tmp_rev = tmp;
                    reverse(tmp_rev.begin(),tmp_rev.end());
                    if(tmp == tmp_rev)
                    {
                        if(tmp.length()>max_len)
                        {
                        max_len = tmp.length();
                        res = tmp;
                        }
                    }
                    
                }
            }
        }
        return res; 
    }
};

Solución dos:

class Solution {
public:
    string longestPalindrome(string s) {
        if(s.length()<2) return s;
        int len = s.length();
        vector<vector<int>> D(len,vector<int>(len));
        for(int i = 0; i < len;i++)
            D[i][i] = 1;
        int max_len = 1;
        int start = 0;
        for(int j = 1; j < len;j++)
        {
            for(int i = 0;i<j;i++)
            {
                if(s[i] == s[j])
                {
                    if(j-i<3)
                        D[i][j] = 1;
                    else
                    {
                        D[i][j] = D[i+1][j-1];
                    }
                }
                else
                    D[i][j] = 0;
                if(D[i][j])
                {
                    if(j-i+1>max_len)
                    {
                        max_len = j-i+1;
                        start = i;
                    }
                }
            }
        }
        return s.substr(start,max_len);
    }
};

Método tres:

class Solution {
public:
    string longestPalindrome(string s) {
        if(s.length()<2) return s;
        int len = s.length();
        int maxLen = 1;
        string res = s.substr(0, 1);
        for(int i = 0; i <len-1;i++)
        {
            string s_odd = centerSpread(s,i,i);
            string s_even = centerSpread(s,i,i+1);
            string maxLenStr = s_odd.size() > s_even.size() ? s_odd : s_even;
            if (maxLenStr.length() > maxLen) {
                maxLen = maxLenStr.size();
                res = maxLenStr;
            }
        }
        return res;
    }
    string centerSpread(string s, int left, int right)
    {
        int i = left;
        int j =right;
        while(i>=0 & j<s.size())
        {
            if(s[i]==s[j])
            {
                i--;
                j++;
            }
            else
                break;
        }
        return s.substr(i+1, j-i-1);
    }
};