【数据结构与算法】万恶的最长回文子串

注意首先区分子串和子序列的区别。最长回文子序列的计算可以用 KMP 算法，以前做过，但是还没搞懂。

这里我们以 leetcode #5. Longest Palindromic Substring 为契机刚好学习下子串的几种常见的求解方式。

算法参考自：LeetCode:Longest Palindromic Substring 最长回文子串（JustDoIT）

1、暴力法

列举出所有可能的子串，然后判断其是否为回文。时间复杂度 O(N^3)。

2、动态规划

用空间换时间。用dp[i][j]表示从 i 开始，长度为 j 的子串是否为回文，用 true 表示是，false 表示不是。算法时间复杂度 O(N^2)，空间复杂度 O(N^2)。

状态转移方程为：

dp[i][j] = (s[i] == s[j]) && d[i + 1][j - 2];

以 "ABBAC" 为例，横轴表示 j，纵轴表示 i，首先初始化前两列 true，然后从 j = 2 开始一列一列填充。

代码如下，时间挺长的，花了 700ms 多。还是慢，需要继续想办法。

class Solution {
public:
    string longestPalindrome(string s) {
        
        int len = s.size();
        int res_start, res_len = 1;
        if(len <= 1)
        {
            return s;
        }
        
        vector<vector<bool> > dp(len + 1, vector<bool> (len + 1));
        int i, j;
        for(i = 0; i <= len; ++i)
        {
            for(j = 0; j < 2; ++j)
            {
                dp[i][j] = true;
            }
        }
        
        for(j = 2; j <= len; ++j)
        {
            for(i = 0; i <= len - j; ++i)
            {
                if((s[i] == s[i + j - 1]) && dp[i + 1][j - 2])
                {
                    dp[i][j] = true;
                    if(j > res_len)
                    {
                        res_start = i;
                        res_len = j;
                    }
                }
            }
        }
        
        return s.substr(res_start, res_len);
    }
};

3、由中心向两边扩展

该算法在计算时需分别计算偶数长度的回文最长子串和奇数长度的回文最长子串。时间复杂度O(N^2)，空间O(1)。

该方法就是暴力求解，但容易理解，且算法复杂度并不高。

class Solution {
public:
    string longestPalindrome(string s) {
        
        int len = s.size();
        if(len <= 1)
        {
            return s;
        }
        
        int left, mid, right, resLeft = 0, resRight = 0, maxLen = 1;
        for(mid = 1; mid < len; ++mid)
        {
            /*奇数长度，以mid为中心*/
            for(left = mid - 1, right = mid + 1; left >= 0 && right < len; --left, ++right)
            {
                if(s[left] != s[right]) break;
                if(maxLen < (right - left + 1))
                {
                    maxLen = right - left + 1;
                    resLeft = left;
                    resRight = right;
                }
            }
        
            /*偶数长度，以mid-1和mid为中心*/
            for(left = mid - 1, right = mid; left >= 0 && right < len; --left, ++right)
            {
                if(s[left] != s[right]) break;
                if(maxLen < (right - left + 1))
                {
                    maxLen = right - left + 1;
                    resLeft = left;
                    resRight = right;
                }
            }
        }
        
        return s.substr(resLeft, maxLen);
    }
};

和DP相比，时间算法复杂度一样，但是在平台上的运行时间只有 56ms。。。。

4、Manacher算法

该算法时间复杂度O(N), 空间复杂度O(N)