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”

题意：如果一个字符串从左向右写和从右向左写是一样的，这样的字符串就叫做palindromic string，如aba,或者abba。本题是这样的，给定输入一个字符串，要求输出一个子串，使得子串是最长的padromic string(即最长回文字符串)。
1.动态规划(dp)
       我们维护一个二维数组dp，其中dp[i][j]表示字符串区间[i, j]是否为回文串，当i = j时，只有一个字符，肯定是回文串，如果i = j + 1，说明是相邻字符，此时需要判断s[i]是否等于s[j]，如果i和j不相邻，即i - j >= 2时，除了判断s[i]和s[j]相等之外，dp[j + 1][i - 1]若为真，就是回文串，通过以上分析，可以写出递推式如下：

dp[i, j] = 1                                           if i == j

         = s[i] == s[j]                              if j = i +1

         = s[i] == s[j] && dp[i + 1][j - 1]         if j > i + 1      

这里有个有趣的现象就是如果我把下面的代码中的二维数组由int改为vector之后就会超时，这说明int型的二维数组访问执行速度完爆std的vector啊，所以以后尽可能的还是用最原始的数据类型吧。
代码：

class Solution {
public:
    string longestPalindrome(string s) {
        int dp[s.size()][s.size()] = {0}, left = 0, right = 0, len = 0;
        for (int i = 0; i < s.size(); ++i) {
            for (int j = 0; j <=i; ++j) {
                dp[j][i] = (s[i] == s[j] && (i - j < 2 || dp[j + 1][i - 1]));
                if (dp[j][i] && len < i - j + 1) {
                    len = i - j + 1;
                    left = j;
                    right = i;
                }
            }
        }
        return s.substr(left, right - left + 1);
    }
};

2.传统算法
       我们知道传统的验证回文串的方法就是两个两个的对称验证是否相等，那么对于找回文字串的问题，就要以每一个字符为中心，像两边扩散来寻找回文串，这个算法的时间复杂度是O(n*n)，可以通过OJ，就是要注意奇偶情况，由于回文串的长度可奇可偶，比如”bob”是奇数形式的回文，”noon”就是偶数形式的回文，两种形式的回文都要搜索，参见代码如下：

// Time complexity O(n*n)
class Solution {
public:
    int Match(string &s,int i,int j)
    {
        int ans=0;
        int len=s.length();
        if(i==j)
        {
            j++;
            i--;
            ans=1;
        }
        while(i>=0&&j<len&&s[i]==s[j])
        {
            ans+=2;
            i--;
            j++;
        }
        return ans;
    }
    string longestPalindrome(string s) {
        int i,j;
        int startPoint=0;
        int len=s.length();
        int max=1;
        for(i=0;i<len;i++)
        {
            if(max<Match(s,i,i))
            {
                max=Match(s,i,i);
                startPoint=i-max/2;
            }
        }
        for(i=0;i<len-1;i++)
        {
            if(max<Match(s,i,i+1))
            {
                max=Match(s,i,i+1);
                startPoint=i-max/2+1;
            }
        }
        return s.substr(startPoint,max);
    }
};

3.Manacher’s Algorithm 马拉车算法
       大名鼎鼎的马拉车算法Manacher’s Algorithm，这个算法的神奇之处在于将时间复杂度提升到了O(n)这种逆天的地步，而算法本身也设计的很巧妙，很值得我们掌握，参见另一篇专门介绍马拉车算法的博客马拉车算法，代码实现如下：

class Solution {
public:
    string longestPalindrome(string s) {
        string t ="$#";
        for (int i = 0; i < s.size(); ++i) {
            t += s[i];
            t += '#';
        }
        int p[t.size()] = {0}, id = 0, mx = 0, resId = 0, resMx = 0;
        for (int i = 0; i < t.size(); ++i) {
            p[i] = mx > i ? min(p[2 * id - i], mx - i) : 1;
            while (t[i + p[i]] == t[i - p[i]]) ++p[i];
            if (mx < i + p[i]) {
                mx = i + p[i];
                id = i;
            }
            if (resMx < p[i]) {
                resMx = p[i];
                resId = i;
            }
        }
        return s.substr((resId - resMx) / 2, resMx - 1);
    }
};

另：string substr (size_t pos = 0, size_t len = npos) const;
产生子串：返回一个新建的初始化为string对象的子串的拷贝string对象。
子串是，在字符位置pos开始，跨越len个字符（或直到字符串的结尾，以先到者为准）对象的部分。
注：在LeetCode上面三种算法时间复杂度越来越低。