leetcode: Longest Palindromic Substring

Given a string S, find the longest palindromic substring in S. You may assume that the maximum length of S is 1000, and there exists one unique longest palindromic substring.

更快的AC，中心扩展法，从每一个点开始向两边扩展，比动态规划快在一旦两边不相等，就停止，动态规划需要全部判断完

class Solution {
public:
    string longestPalindrome(string s) {
        if( s.size() <= 1)
            return s;
        const int N = s.size();
        //vector< vector< bool> > dp( N, vector< bool>( N, false));
        int max_length = 0;
        int res_start = 0;
        for( int i = 0; i < s.size(); ++i){
            int left_start = i - 1;
            int right_start = i + 1;
            while( left_start >= 0 && right_start < s.size() && s[left_start] == s[right_start]){
                --left_start;
                ++right_start;
            }
            if( max_length < right_start - left_start - 1){
                max_length = right_start - left_start - 1;
                res_start = left_start + 1;
            }
            left_start = i;
            right_start = i + 1;
            while( left_start >= 0 && right_start < s.size() && s[left_start] == s[right_start]){
                --left_start;
                ++right_start;
            }
            if( max_length < right_start - left_start - 1){
                max_length = right_start - left_start - 1;
                res_start = left_start + 1;
            }
        }
        return s.substr( res_start, max_length);
    }
};

动态规划

AC，把赋值分开来写，就AC了，把判断另外写个循环，说明超时就超了一点，节省了每次循环的时间

class Solution {
public:
    string longestPalindrome(string s) {
        if( s.size() <= 1)
            return s;
        const int N = s.size();
        //vector< vector< bool> > dp( N, vector< bool>( N, false));
        bool dp[N][N];
        fill_n(&dp[0][0], N * N, false);
        int max_length = 0;
        int index = 0;
        for( int i = 0; i < N; ++i){
            dp[i][i] = true;
        }
        for( int i = 0; i < N; ++i){
            for( int j = 0; j < i; ++j){
                if( s[j] == s[i] && ( dp[j+1][i-1] || j == i - 1)){
                    dp[j][i] = true;
                    if( max_length < i - j + 1){
                        max_length = i - j + 1;
                        index = j;
                    }
                } 
            }
        }
        return s.substr( index, max_length);
    }
};

TLE

class Solution {
public:
    string longestPalindrome(string s) {
        if( s.size() <= 1)
            return s;
        const int N = s.size();
        //vector< vector< bool> > dp( N, vector< bool>( N, false));
        bool dp[N][N];
        fill_n(&dp[0][0], N * N, false);
        int max_length = 0;
        int index = 0;
        for( int i = 0; i < N; ++i){
            dp[i][i] = true;
            for( int j = 0; j < i; ++j){
                if( s[j] == s[i] && ( dp[j+1][i-1] || j == i - 1)){
                    dp[j][i] = true;
                    if( max_length < i - j + 1){
                        max_length = i - j + 1;
                        index = j;
                    }
                } 
            }
        }
        return s.substr( index, max_length);
    }
};