LeetCode从零刷起 (5. 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.

Example:
Input: "babad"
Output: "bab"
Note: "aba" is also a valid answer.

Example:
Input: "cbbd"
Output: "bb"

题目简介

这道题输入是一个字符串，要求输出最长的回文子串。

知识要点

1. 动态规划的思想
2. 对称的思想

解题思路

Approach 1: Brute Force

暴力法应该是最朴素的算法了：我们查找所有的子串，判断是否为回文并记录最长回文子串。这种算法笔者在此不列代码。
关于时间复杂度，寻找所有子串为O(n^{2)，判断是否为回文为O(n)，所以总的时间复杂度为O(n}3)。

Approach 2: Dynamic Programming

这道题应用动态规划来解题应该还是很容易想到的。设置一个dp布尔型二维数组，其中dp[i][j]表示字符串从第i位置到第j位置（包括i,j）是否为回文。那么很容易得到状态转移方程：if ( dp[i+1][j-1] == true && s[i] == s[j] ) dp[i][j] = true; dp数组初始化操作见代码中pre-process部分。
c++代码如下：

class Solution {
public:
    //dynamic programming
    string longestPalindrome(string s) {
        int len = s.length();
        bool dp[1010][1010] = {0};
        int i, j;
        int maxL=1, start=0, tmpL;
        
        //pre-processing
        for (i=0; i

时间复杂度为O(n^2)

Approach 3: Expand Around Center

第三种算法被称为中心扩展法。核心思想为：从左到右遍历字符串，从“中心”向两边扩展直到不再是回文。该算法要注意的是“中心”的选择：有两种情况，“aba”和“abba”。前者中心为一个字符，后者中心为两个字符。我们对两种情况分别进行处理。
C++代码如下：

class Solution {
public:
    //expand around center
    string longestPalindrome(string s) {
        int len = s.length();
        int maxL = 1, start = 0, tmpL;
        int i, j, k;
        
        //aba type
        for (i=0; i=0 && k maxL){
                    maxL = tmpL;
                    start = j;
                }
                j--;
                k++;
            }
        }
        
        //abba type
        for (i=0; i=0 && k maxL){
                    maxL = tmpL;
                    start = j;
                }
                j--;
                k++;
            }
        }
        
        //output
        string lp = s.substr(start, maxL);
        return lp;
    }
};

时间复杂度为O(n^2)

Approach 4: Manacher's Algorithm

这个算法算是一个比较冷门的算法了。不过其思想非常有趣，还是很有理解透彻的价值的。网上的众多文章对该算法的解释并不是很清晰，笔者觉得manacher's algorithm这篇文章算是解释最好的一篇了，转过来参考一下。
笔者依据该算法的思想自己用C++实现了一下：

class Solution {
public:
    //manacher's algorithm
    //add # to the string 
    string pre_process(string s){
        string pps = "#";
        for (int i=0; i radius){
                radius = p[i];
                center = i;
            }
        }
        string ans = "";
        for (int i=center-radius; i<=center+radius; ++i){
            if (s[i] != '#')
                ans += s.substr(i, 1);
        }
        return ans;
    } 
     
    string longestPalindrome(string s){
        s = pre_process(s); 
        int p[2010]; //the radius of palindromic substring, not including character in i
        int maxlen = 0, maxi = 0;
        p[0] = 0;
        
        //different situations of manacher's algorithm
        for (int i=1; i= maxlen, the point is out of the range
            if (i >= maxlen){
                p[i] = 0;
                while ( i-(p[i]+1)>=0 && i+(p[i]+1) maxlen){
                    maxi = i;
                    maxlen = maxi+p[i];
                }
            }
            // i < maxlen, the point is within the range
            else{
                int j = 2*maxi - i; // the symmetric point
                if (j - p[j] < maxi - p[maxi])
                    p[i] = maxlen - i;
                else if (j - p[j] > maxi - p[maxi])
                    p[i] = p[j];
                else{
                    p[i] = p[j];
                    while ( i-(p[i]+1)>=0 && i+(p[i]+1) maxlen){
                        maxi = i;
                        maxlen = maxi+p[i];
                    }
                }
            }
        }
        string ansstr = post_process(s, p, s.length());;
        return ansstr;
    }
};

该算法时间复杂度达到了O(n)
对代码的一些说明：

1. pre-process函数是为字符串没个字符之间添加‘#’，使得“aba”型和“abba”型能够统一处理。
2. post-process函数是输出处理。寻找最大回文半径，并将‘#’删除掉。返回最终的输出。
3. 算法的主体部分的思想参考manacher's algorithm这篇文章。

参考

1. http://blog.csdn.net/xingyeyongheng/article/details/9310555