tags: String

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.

Examples:

• a → a
• abba → abba
• aba → aba
• abbacc → abba
• aabcacb → bcacb

Function:

public String longestPalindrome(String s) {
    // Your Code
}

題目分析

該題目是字符串類型的Medium題目，要求找到字符串中最長的回文子串（LeetCode 3的題目中解釋了substring和subsequence的區別），回文串就是順序和逆序相同的字符串，如Examples所示。最樸素的想法是找到字符串的所有子串，查看每個子串是否是回文串，這種算法的時間復雜度是O(n3)，這里不再展示其實現（因為我也沒想到這么樸素的想法O_O）。下面展示另外兩種算法，第一個是枚舉算法，另一個是Manacher算法，后者的時間復雜度都能達到O(n)，實在是查找回文串的不二選擇。

算法1：枚舉算法

public String longestPalindrome(String s) {
    char[] chArray = s.toCharArray();
    int len = chArray.length;
    if (len < 2)
        return s;

    String result = s.substring(0, 1);
    int minLength = 0;
    for (int i=0; i<len-1; i++) {
        if (chArray[i] == chArray[i+1]) {
            int j=0;
            while (i-j>=0 && i+1+j<len && chArray[i-j]==chArray[i+1+j]) {
                j++;
            }
            if (minLength < j*2) {
                minLength = j*2;
                result = String.valueOf(chArray, i-j+1, minLength);
            }
        }
    }
    for (int i=1; i<len-1; i++) {
        if (chArray[i-1] == chArray[i+1]) {
            int j=1;
            while (i-j>=0 && i+j<len && chArray[i-j]==chArray[i+j]) {
                j++;
            }
            j--;
            if (minLength < j*2+1) {
                minLength = j*2+1;
                result = String.valueOf(chArray, i-j, minLength);
            }
        }
    }
    return result;
}

該算法遍歷字符串，以每個字符或兩個一樣的字符為中心，向兩邊查找對稱字符，進而找到最長的字符串。代碼中兩個for循環分別查找以單字符和雙字符為中心的回文串，這里不再贅述。下面分析一下該算法的時間復雜度，在for循環內部存在while循環，該循環判斷兩邊的字符是否對稱，其長度與n有關，所以時間復雜度應為O(n2)，該實現可以AC，運行時間中等。

算法2：Manacher算法

public String longestPalindromeWithManacher(String s) {
    char[] chArray = s.toCharArray();
    int len = chArray.length * 2 + 3;
    char[] nch = new char[len];
    nch[0] = '@'; // 3. 添加特殊字符，防止訪問越界
    nch[len-1] = '$';
    for (int i=1; i<len-1; i++) {
        if ((i & 1) != 0) {
            nch[i] = '#'; // 1. 在字符串中添加特殊字符，將兩種情況統一解決
        } else {
            nch[i] = chArray[(i>>1) - 1];
        }
    }
    int[] p = new int[len];

    int maxid = 0, center = 0, longest = 1, longestCenter = 0;
    for (int i=1; i<len-1; i++) {
        // 2. 算法的精華
        if (maxid > i) {
            p[i] = Math.min(p[2*center-i], maxid-i);
        } else {
            p[i] = 1;
        }
        while (nch[i-p[i]]==nch[i+p[i]]) {
            p[i]++;
        }
        if (p[i]+i > maxid) {
            maxid = p[i]+i;
            center = i;
        }
        if (longest < p[i]) {
            longest = p[i];
            longestCenter = center;
        }
    }

    StringBuilder sb = new StringBuilder();
    for (int i=longestCenter+1-longest; i<longestCenter+longest; i++) {
        if (nch[i] != '#')
            sb.append(nch[i]);
    }
    return sb.toString();
}

在找該題目最優解法之前，我沒聽說過Manacher算法，而瀏覽的很多博客對該算法的理解和解釋都很輕率，甚至有誤，目前看到分析最認真準確的博客是acm_xyyh的博客。以下從3點討論Manacher算法的關鍵和特殊的編程技巧。

1. 在字符串中添加特殊字符，將兩種情況統一解決。在算法1中需要處理單字符為中心和雙字符為中心的情況，Manacher算法通過向其中插入分隔符（本例用的#），將這兩種情況轉為單字符為中心的情況，即aba->#a#b#a#以b為中心，aa->#a#a#以#為中心。
2. 算法的精華。對于遍歷的每一個字符串，它有兩種情況，處在某個回文串中和不在任何回文串中。對于后者，只能以該點為中心向兩邊比較；對于前者，應充分利用回文串的對稱性，查看對稱節點的回文長度提供當前節點回文長度，這里有3種情況，acm_xyyh的博文已介紹的很清晰，可以參考。
3. 添加特殊字符，防止訪問越界。這是一種編程技巧，在《編程珠璣》中也有介紹。添加這種字符的意義在于減少數據邊界的比較次數，如算法1中在向兩邊檢查對稱性時都需要判斷下標是否越界，而本算法利用特殊字符和字符比較即可跳出while循環，能減少大量的下標越界檢查，提高算法效率。

最后分析一下Manacher算法的時間效率，該算法需要遍歷字符串，另一方面，算法只有遇到還沒匹配的位置時才進行匹配，已匹配過的位置不再進行匹配，所以其時間復雜度為O(n)，超過了Java AC的99%。

總結

字符串類型的題目有很多高效但晦澀的算法，Manacher算法應該算一個，不過算法2的實現還有一些編程技巧上值得借鑒的地方：

• 利用處理數據的特殊性質，可以提供高效的解法；
• 對于需要分兩種情況解決的方案，通常會有一種方法來優雅的合并，如上面插入的分隔符；
• 在數組中利用特殊數組防止數組訪問越界。

參考

1. http://blog.csdn.net/xingyeyongheng/article/details/9310555
2. http://www.open-open.com/lib/view/open1419150233417.html