5. 最長迴文子串

思路一：中心擴充套件法

參考：https://leetcode-cn.com/problems/palindromic-substrings/solution/liang-dao-hui-wen-zi-chuan-de-jie-fa-xiang-jie-zho/

選定中心點後，同時判斷左右字元是否相等，如果相等，則構成了迴文子串，再繼續向左右擴張，判斷是否能形成更長的迴文子串。

首先每個字元都可以是中心點，其次所有相鄰的兩個字元也可以中心點，比如abba, 如果以單個字元中心點，那麼abba這最長的迴文子串就永遠統計不到，但是如果以 bb 為中心點，則能統計到這個迴文子串。

至於為什麼三個相鄰的字元，四個相鄰的字元不是中心點，因為三個相鄰的字元可以是單箇中心點擴充套件一次得到，四個相鄰的字元可以是兩個相鄰的字元擴充套件一次得到。所以中心點的個數為 2n-1, n 字串長度。

 1 class Solution {
 2     public String longestPalindrome(String s) {
 3         // 中心擴充套件法
 4         if(s == null){
 5             return null;
 6         }
 7         int maxLength = 0;      // 當前迴文子串的最大長度
 8         String maxPalindrome = "";
 9         int len = s.length();
10         for(int center = 0; center < 2 * len - 1; center++){
 
11             int left = center / 2;
12             int right = center / 2  + center % 2;
13             while(left >= 0 && right < len && s.charAt(left) == s.charAt(right)){
14                 if(right - left + 1 > maxLength){
15                     maxLength = right - left + 1;
 
16                     maxPalindrome = s.substring(left, right + 1);
17                 }
18                 left--;
19                 right++;
20             }
21         }
22         return maxPalindrome;
23     }
24 }

leetcode 執行用時：40 ms > 51.97%, 記憶體消耗：39.3 MB> 55.85%

複雜度分析：

時間複雜度：只有一個for迴圈，所以時間複雜度為O(n)

空間複雜度：O(1)

思路二：動態規劃

參考：https://leetcode-cn.com/problems/palindromic-substrings/solution/shou-hua-tu-jie-dong-tai-gui-hua-si-lu-by-hyj8/

動態規劃，二維陣列，dp[i][j]是個布林值，表示[i,j]之間的子串是否是迴文串 區間只有一個字元肯定是迴文串 區間只有兩個字元，且兩個字元相等，那也是迴文串 如果[i,j]兩個端點的字元相等且內部子串dp[i+1][j-1]也是迴文串，那整個區間都是迴文串 其實上面三種情況可以歸納為，如果區間兩端字元相等，且區間長度小於等於2或者大於2但是內部是迴文串，那麼整個區間都是迴文串，借用上面參考文章作者的一張圖 因為轉態轉移方程中求dp[i][j]時用到了dp[i+1][j-1],所以我們的外層迴圈應該迴圈j, 當前 j 把內層迴圈的的所有 i 都迭代一遍，這樣dp[i][j]使用dp[i+1][j-1]就沒有問題了

 1 class Solution {
 2     public String longestPalindrome(String s) {
 3         // 動態規劃
 4         if(s == null){
 5             return null;
 6         }
 7         int maxLength = 0;      // 當前迴文子串的最大長度
 8         String maxPalindrome = "";
 9         int len = s.length();
10         boolean[][] dp = new boolean[len][len]; // 儲存[i, j]區間的子串是否為迴文子串
11         for(int j = 0; j < len; j++){
12             for(int i = 0; i <= j; i++){
13                 if(s.charAt(i) == s.charAt(j) && (j - i <= 1 || dp[i+1][j-1])){
14                     dp[i][j] = true;
15                     if(maxLength < j - i + 1){
16                         maxLength = j - i + 1;
17                         maxPalindrome = s.substring(i, j+1);
18                     }
19                 }
20             }
21         }
22         return maxPalindrome;
23     }
24 }

leetcode執行用時：257 ms > 11.41%,記憶體消耗：45.1 MB > 5.76%, 比思路一慢了很多，多了空間，也多了時間

複雜度分析：

時間複雜度：兩個for迴圈， 所以空間複雜度為O(n²)

空間複雜度：需要一個n* n的矩陣，所以空間複雜度為O(n²)

空間降維

 1 class Solution {
 2     public String longestPalindrome(String s) {
 3         // 動態規劃
 4         if(s == null){
 5             return null;
 6         }
 7         int maxLength = 0;      // 當前迴文子串的最大長度
 8         String maxPalindrome = "";
 9         int len = s.length();
10         boolean[] dp = new boolean[len]; // 儲存[i, j]區間的子串是否為迴文子串
11         for(int j = 0; j < len; j++){
12             for(int i = 0; i <= j; i++){
13                 if(s.charAt(i) == s.charAt(j) && (j - i <= 1 || dp[i+1])){
14                     dp[i] = true;
15                     if(maxLength < j - i + 1){
16                         maxLength = j - i + 1;
17                         maxPalindrome = s.substring(i, j+1);
18                     }
19                 }else{
20                     dp[i] = false;
21                 }
22             }
23         }
24         return maxPalindrome;
25     }
26 }

leetcode 執行用時：247 ms > 11.58%, 記憶體消耗：39.2 MB > 54.45%, 時間效率基本沒變，但是空間效率提升了很多

複雜度分析：

時間複雜度：兩個迴圈，遍歷了 len * len /2個元素，所以時間複雜度為O(n²) 空間複雜度：只需要一個長度為 n的矩陣，所以空間複雜度為O(n)