Leetcode解题笔记之（五）--Longest Palindromic Substring [Medium]

解题思路

题目要求我们寻找长度最长的回文子字符串，这个问题其实很简单但是解法有不同。
首先，我们可以采用暴力解决。直接比较出最长的那个，以每一个字符为中心，像两边扩散来寻找回文串，这个算法的时间复杂度是O(n*n)。

另外一个经典的解法就是动态规划解法，这是动态规划的经典案例。构建子问题：
设d[i][j]表示字符串s从第i个字符到第j个字符为回文（字符串从0开始），则
若d[i+1][j-1] == true，并且s[i] == s[j]，则d[i][j] == true；

初始化
由于算法运行只能判断3个字符以上回文的情况，我们要预先对d[i][i], d[i][i+1]进行赋值。

遍历
为了避免考虑字符串边界的问题，需要谨慎设计循环，不要直接拿i,j去进行循环，而是把j设为i - len + 1，从而避免了出界。
这两种解法的比较直接向我们展现了算法的强大作用。

代码

暴力查找法

void findPal(string &s, int j, int k, int &max_len, string &res) {
        int ls = s.size();
        while (j >= 0 && k <= ls - 1 && s[j] == s[k]) {
            --j;
            ++k;
        }
        if (k - j - 1 > max_len) {
            max_len = k - j - 1;
            res = s.substr(j + 1, max_len);
        }
    }
string longestPalindrome(string s) {
        int max_len = 0;
        string res = "";
        int ls = s.size();
        int i, j, k;
        
        for (i = 0; i < ls; ++i) {
            findPal(s, i - 1, i + 1, max_len, res);
        }
        
        for (i = 0; i + 1 < ls; ++i) {
            findPal(s, i, i + 1, max_len, res);
        }
        
        return res;
    }

动态规划算法

#define MAX_N 1000

string longestPalindrome(string s) {
    bool f[MAX_N][MAX_N] = {false};

    //  情况一
    int begin = 0;
    int maxLen = 1;
    for (int i = 0; i < s.length(); i++) {
        f[i][i] = true;
    }

    //  情况二
    for (int i = 0; i < s.length() - 1; i++) {
        if (s[i] == s[i + 1]) {
            begin = i;
            maxLen = 2;
            f[i][i + 1] = true;
        } 
    }

    //  情况三
    for (int len = 3; len <= s.length(); len++) {
        for (int i = 0; i < s.length() - len + 1; i++) {
            int j = i + len - 1;
            if (s[i] == s[j] && f[i + 1][j - 1]) {
                maxLen = len;
                begin = i;
                f[i][j] = true;
            }
        }
    }
    return s.substr(begin, maxLen);
}