最长回文子串---二维DP

题目描述

给你一个字符串 s，找到 s 中最长的回文子串。

示例 1：

输入：s = "babad"

输出："bab"

解释："aba" 同样是符合题意的答案。

思路

代码

#include <iostream>
#include <string>
#include <vector>

using namespace std;

class Solution {
public:
    string longestPalindrome(string s) {
        // 获取字符串 s 的长度
        int length = s.length();

        // 设置数组 dp，用来存储字符串 s 的 [i,j] 区间的子串是否是回文子串
        // dp[0][0] 表示字符串 s 第 0 个字符和字符串 s 第 0 个字符之间的子串是否是回文子串
        // dp[2][3] 表示字符串 s 第 2 个字符和字符串 s 第 3 个字符之间的子串是否是回文子串
        // dp[i][j] 表示字符串 s 第 i 个字符和字符串 s 第 j 个字符之间的子串是否是回文子串
        // i 最大值为 length - 1
        auto dp = vector < vector < bool>>(length, vector<bool>(length));

        // dp[0][0] 表示字符串 s 第 0 个字符和字符串 s 第 0 个字符之间的的子串是否是回文子串
        // dp[3][3] 表示字符串 s 第 3 个字符和字符串 s 第 3 个字符之间的的子串是否是回文子串
        // dp[i][i] 表示字符串 s 第 i 个字符和字符串 s 第 i 个字符之间的的子串是否是回文子串
        // 此时，这个区间的字符只有一个，肯定是回文子串
        for (int i = 0; i < length; i++) {
            dp[i][i] = true;
        }

        // 设置变量记录最长的回文子串的长度
        int maxLen = 1;

        // 设置变量记录最长的回文子串的开始位置
        // 从后向前寻找
        int begin = length - 1;

        // i 从字符串 s 的【尾部】开始向前遍历，j 从 i + 1 开始向后遍历
        // 不断的逼近二维数组最右上角的位置，即求 dp[0][length - 1]
        for (int i = length - 1; i >= 0; i--) {

            for (int j = i + 1; j < length; j++) {

                // 如果发现 s.charAt(i) == s.charAt(j)
                if (s[i] == s[j]) {

                    // 如果 [i , j] 这个区间中只有 2 个字符，并且此时两个字符还是一样的
                    // 那么肯定是回文子串
                    // 假设 i = 5， j = 6，[i , j] 这个区间中只有 2 个字符
                    // 如果不加这个判断的话，dp[i][j] = dp[ i + 1 ][ j - 1 ]
                    // 此时，i + 1 = 6， j - 1 = 5
                    // [ 6 , 5 ] 这个区间不存在，默认值为 false
                    if ((j - i + 1) == 2) {

                        dp[i][j] = true;

                    }
                    else {

                        // 否则，当前这个区间是否是回文子串区间取决于 [ i + 1 , j - 1 ] 这个区间
                        dp[i][j] = dp[i + 1][j - 1];

                    }

                }
                else {
                    // 如果发现 s.charAt(i) ！= s.charAt(j)
                    // 那说明 [i , j] 这个区间必然不是回文子串
                    dp[i][j] = false;

                }

                // 更新最长的回文子串长度
                if (dp[i][j] && j - i + 1 > maxLen) {
                    // 更新最长的回文子串长度
                    maxLen = j - i + 1;
                    // 更新最长的回文子串的开始位置
                    begin = i;
                }


            }

        }

        // 通过截取的方式返回最长的回文子串
        // Java substring() 方法
        // beginIndex -- 起始索引（包括）, 索引从 0 开始
        // endIndex -- 结束索引（不包括）
        //  0  1  2  3  4
        //  b  a  b  a  d
        // 此时，begin = 1，maxLen = 3
        // substring( 1 , 4 )，即截取 [1 , 4 ) ，左闭右开的区间
        // 获取子串  aba
        return s.substr(begin, maxLen);

    }
};

class Solution1 {
public:
    string longestPalindrome(string s) {
        int n = s.size();
        if (n < 2) {
            return s;
        }

        int maxLen = 1;
        int begin = 0;
        // dp[i][j] 表示 s[i..j] 是否是回文串
        vector<vector<int>> dp(n, vector<int>(n));
        // 初始化：所有长度为 1 的子串都是回文串
        for (int i = 0; i < n; i++) {
            dp[i][i] = true;
        }
        // 递推开始
        // 先枚举子串长度
        for (int L = 2; L <= n; L++) {
            // 枚举左边界，左边界的上限设置可以宽松一些
            for (int i = 0; i < n; i++) {
                // 由 L 和 i 可以确定右边界，即 j - i + 1 = L 得
                int j = L + i - 1;
                // 如果右边界越界，就可以退出当前循环
                if (j >= n) {
                    break;
                }

                if (s[i] != s[j]) {
                    dp[i][j] = false;
                }
                else {
                    if (j - i < 3) {
                        dp[i][j] = true;
                    }
                    else {
                        dp[i][j] = dp[i + 1][j - 1];
                    }
                }

                // 只要 dp[i][L] == true 成立，就表示子串 s[i..L] 是回文，此时记录回文长度和起始位置
                if (dp[i][j] && j - i + 1 > maxLen) {
                    maxLen = j - i + 1;
                    begin = i;
                }
            }
        }
        return s.substr(begin, maxLen);
    }
};

int main() {
    string s;
    getline(cin, s);
    Solution a;
    cout << a.longestPalindrome(s);
}

复杂度分析

时间复杂度：O(n2)，其中 n 是字符串的长度。动态规划的状态总数为 O(n2)，对于每个状态，我们需要转移的时间为 O(1)。

空间复杂度：O(n2)，即存储动态规划状态需要的空间。