【Leetcode】最長迴文子串

啓發

1）作題前必定要讀懂題目

在本題中，首先要清楚地定義迴文子串的概念，而後才能設計算法查找它。

如中心擴散法，其主要思想在於找到一個迴文子串的定義——兩側互爲鏡像。進一步分爲奇數長度和偶數長度進行討論。

在這裏附上kaggle宗師高志峯的心得，

 

2）查找的過程要很是注意邊界的處理

這每每是很是容易放錯的地方！

 

中心擴散法

咱們觀察到迴文中心的兩側互爲鏡像。所以，迴文能夠從它的中心展開，而且只有 2n−1 個這樣的中心。

你可能會問，爲何會是 2n−1 個，而不是 n 箇中心？緣由在於所含字母數爲偶數的迴文的中心能夠處於兩字母之間（例如「abba」 的中心在兩個‘b’ 之間）。

時間複雜度 O(n^2), 因爲圍繞中心來擴展迴文會耗去 O(n) 的時間，因此總的複雜度爲 O(n^2);

空間複雜度 O(1);

執行用時 :  128 ms, 在Longest Palindromic Substring的C++提交中擊敗了54.24% 的用戶

內存消耗 :  104 MB, 在Longest Palindromic Substring的C++提交中擊敗了26.33% 的用戶

class Solution {
public:
    string longestPalindrome(string s) {
        if (s == "" || s.size()== 1)
        {
            return s;
        }
        int size = s.size();
        int start = 0;
        int max = 1;
        int len1 = 0, len2 = 0;
        int len = 0;
        for (int i = 0; i < size; i++)
        {
            len1 = retRomeLen(s, i, i);
            len2 = retRomeLen(s, i, i + 1);
            len = len1>len2 ? len1 : len2;
            if (len > max)
            {    
                max = len;
                start = i - (len-1) / 2;
            }
        }
        
        return s.substr(start, max);
    }
    // 中心擴散的寬度
    int retRomeLen(string s, int left, int right)
    {
        while (left >= 0 && right < s.size() && s[left] == s[right] )
        {    
            left--;
            right++;
        }return right - left -1;
    }
};

 

把上述代碼中查找回文的函數改爲以下，

int retRomeLen(string& s, int left, int right)

結果大幅度提高，

執行用時 :  24 ms, 在Longest Palindromic Substring的C++提交中擊敗了85.89% 的用戶

內存消耗 :  8.6 MB, 在Longest Palindromic Substring的C++提交中擊敗了96.80% 的用戶

 

動態規劃

時間複雜度：O(n^2)。將長度爲n的字符串從前日後劃分爲1,2,3……n-1，n的子串，在每一個子串內尋找回文。前一個子串中的迴文尋找結果將被後一個子串所使用。

空間複雜度：O(n^2)

執行用時 :  172 ms, 在Longest Palindromic Substring的C++提交中擊敗了46.34% 的用戶

內存消耗 :  9.8 MB, 在Longest Palindromic Substring的C++提交中擊敗了66.80% 的用戶

class Solution {
public:
    string longestPalindrome(string s) {
        int n=s.size();
        if(n==0) return s;
        bool dp[n][n];
        memset(dp,0,sizeof(dp));
        int maxlen=1,start=0;
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<=i;j++)
            {
                if(i-j<2) dp[i][j]=(s[i]==s[j]);
                else
                    dp[i][j]=(s[i]==s[j]&&dp[i-1][j+1]==1);
                if(dp[i][j]&&maxlen<i-j+1)
                {
                    maxlen=i-j+1;
                    start=j;
                }
            }
        }
        return s.substr(start,maxlen);
            
    }
};

動態規劃法解析：

https://leetcode-cn.com/problems/longest-palindromic-substring/solution/xiang-xi-tong-su-de-si-lu-fen-xi-duo-jie-fa-bao-gu/ 

 

偶然穿插的代碼優化：

中心擴散法的空間複雜度是 O(1)，遠遠優於動態規劃法的 O(n^2)，然而內存消耗倒是十倍。思考以後獲得啓發！中心擴散法中爲使代碼更爲美觀，將查找回文的功能封裝成一個函數進行調用。在函數調用過程當中，內存須要開闢一塊棧空間，存儲函數調用的各類信息。儘管函數執行過程當中耗費的內存很小，幾乎能夠忽略，然而爲了記錄函數調用產生的數據，卻佔了大頭。

將中心擴散法的代碼改爲以下形式，取消函數的調用，效果改變顯著！

執行用時 :  36 ms, 在Longest Palindromic Substring的C++提交中擊敗了75.65% 的用戶

內存消耗 :  8.9 MB, 在Longest Palindromic Substring的C++提交中擊敗了91.93% 的用戶

class Solution {
public:
    string longestPalindrome(string s) {
        if (s == "" || s.size()== 1)
        {
            return s;
        }
        int size = s.size();
        int start = 0;
        int max = 1;
        int len1 = 0, len2 = 0;
        int len = 0;
        for (int i = 0; i < size; i++)
        {
            int left = i, right = i;
            while (left >= 0 && right < s.size() && s[left] == s[right] )
            {    
                left--;
                right++;
            }
            len1 = right - left -1;
            
            left = i; right = i+1;
            while (left >= 0 && right < s.size() && s[left] == s[right] )
            {    
                left--;
                right++;
            }
            len2 = right - left -1;
            
            len = len1>len2 ? len1 : len2;
            if (len > max)
            {    
                max = len;
                start = i - (len-1) / 2;
            }
        }
        
        return s.substr(start, max);
    }

};