LeetCode OJ-5.Longest Palindromic Substring(最长回文子串)

LeetCode OJ-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"

题目理解

​ 题目是要求解最长的回文子串，回文串说的是正着写和反着写结果都是一样的字符串，具体可以看个例子：”bab”就是一个回文串，”aa”也是一个回文串。形式则是第1个字符与第n个字符相等，第2个字符与第n - 1个字符相等，第3个字符与第n - 2个字符相等，以此类推。

时间复杂度为O(n^3)的暴力解法

​ 简单的解法可以从回文串的基本形式想到，可以从某个子串的起始与结束位置向中间渐渐靠拢，若出现不相等的情况，则说明这个子串不可能是回文串。由此可以得到一个时间复杂度为O(n^3)的解法，其中起始位置在最外层循环迭代，而结束位置这里不直接进行迭代，而是在第二层进行子串长度的迭代，则结束位置则为len - 1，最内层循环则是由两边向中间靠拢去判断是否为回文串。PS: 这个解法会超时，仅是提供一种思路。具体代码如下：

int get_longest_palindromic_substr(const char *str, int *start, int *end,
                                   size_t sz)
{
    int res = 0;
    int i, j;
    int k, l;
    for (i = 0; i < sz; ++i) {
        for (j = 1; j < sz && i + j < sz; ++j) {
            k = i;
            l = j;
            while (k < l) {
                if (str[k] == str[l]) {
                    if (k + 1 < l) {
                        ++k;
                        --j;
                    }
                    else {
                        break;
                    }
                }
                else {
                    break;
                }
            }

            if (k + 1 == l && str[k] == str[l] && j - i + 1 > res) {
                *start = i;
                *end = j + 1;   //本来这里应该是j + 1，但若要使用string构造函数中以
                                //迭代器构造的形式，就需要移动到结束位置后一个位置。
                res = j - i + 1;
            }
            else if (k == l && j - i + 1 > res) {
                *start = i;
                *end = j + 1;   //本来这里应该是j + 1，但若要使用string构造函数中以
                                //迭代器构造的形式，就需要移动到结束位置后一个位置。
                res = j - i + 1;
            }
        }
    }
    return res;
}

时间复杂度为O(n^2)的动态规划解法

​ 使用动态规划可以将时间复杂度降为O(n^2)，思路与上面的方法类似，只是引入了一个记录状态的dp数组，空间复杂度提升为O(n^2)。

​ 设dp[i][j]为判断从i到j位置的子串是否为回文串的标志，是则为true，不是则为false。状态方程可写作：

dp[i][j]={ dp[i + 1][j - 1], str[i] == str[j] | dp[i][i], i == j | dp[i][i + 1] str[i] == str[i + 1] }.

​ 对于状态方程的三种状态有如下解释：

1. 当str[i] = str[j]时，dp[i][j]的值由i + 1与j - 1对应的dp值决定，即也是一个从两端向中靠拢判断的过程；

2. 当i = j时，当个的字符自然是回文串，则常为true；

3. 相邻位置的字符构成的子串是否为回文串，则看i和i + 1位置的字符是否相等，相等即为true。

   ​

   有了上述定义，则可以得到代码，对于一些特殊的处理，代码关键位置有注释可参看：

const int g_kMaxSize = 1001; 

int get_longest_palindromic_substr(const char *str, int *start, int *end,
                                   size_t sz)
{
    int max_len = 1;
    bool dp[g_kMaxSize][g_kMaxSize] = { false };
    int i, j;
    int len;
    *start = 0;
    *end = 1;
    for (i = 0; i < sz; ++i) {
        dp[i][i] = true;
    }
    for (i = 0; i < sz - 1; ++i) {
        if (str[i] == str[i + 1]) {
            dp[i][i + 1] = true;
            *start = i;
            *end = i + 2;   //本来这里应该是i + 1，但若要使用string构造函数中以迭代器构造
                            //的形式，就需要移动到结束位置后一个位置。
            max_len = 2;
        }
    }
    for (len = 3; len <= sz; ++len) {
        for (i = 0; i < sz; ++i) {
            j = i + len - 1;
            if (j < sz && str[i] == str[j] && dp[i + 1][j - 1]) {
                dp[i][j] = true;
                *start = i;
                *end = j + 1;   //本来这里应该是j + 1，但若要使用string构造函数中以
                                //迭代器构造的形式，就需要移动到结束位置后一个位置。
                max_len = len;
            }
        }
    }

    return max_len;
}