【LeetCode】647. 回文子串（中等）——代码随想录算法训练营Day57

题目链接：647. 回文子串

题目描述

给你一个字符串 s ，请你统计并返回这个字符串中 回文子串 的数目。

回文字符串 是正着读和倒过来读一样的字符串。

子字符串 是字符串中的由连续字符组成的一个序列。

具有不同开始位置或结束位置的子串，即使是由相同的字符组成，也会被视作不同的子串。

示例 1：

输入：s = "abc"
输出：3
解释：三个回文子串: "a", "b", "c"

示例 2：

输入：s = "aaa"
输出：6
解释：6个回文子串: "a", "a", "a", "aa", "aa", "aaa"

提示：

• 1 <= s.length <= 1000
• s 由小写英文字母组成

文章讲解：代码随想录

视频讲解：动态规划，字符串性质决定了DP数组的定义 | LeetCode：647.回文子串_哔哩哔哩_bilibili

题解1：动态规划

思路：使用动态规划法求解子序列问题。

动态规划分析：

• dp 数组以及下标的含义：dp[i][j] 代表字符串 s 的 [i, j] 部分是否为回文字符串。
• 递推公式：当 s[i] 不等于 s[j] 时，dp[i][j] 为 0。s[i] 等于 s[j] 时，若 j - i 小于等于1或 dp[i + 1][j - 1] 等于1时，dp[i][j] = 1，否则为0。
• dp 数组初始化：dp[i][i] 代表从 i 到 i 是否为回文字符串，答案为是，初始化为1。其余初始化为0。
• 遍历顺序：dp[i][j] 依赖于 dp[i + 1][j - 1]，即左下方。因此遍历顺序为从下往上，从左往右。
• 打印 dp 数组：以输入 "abc" 为例，dp 数组为 [ [ 1, 0, 0 ], [ 0, 1, 0 ], [ 0, 0, 1 ] ]。

/**
 * @param {string} s
 * @return {number}
 */
var countSubstrings = function(s) {
    const dp = new Array(s.length).fill().map(() => new Array(s.length).fill(0));
    let res = 0;
    for (let i = s.length - 1; i >= 0; i--) {
        for (let j = i; j < s.length; j++) {
            if (s[i] === s[j] && (j - i <= 1 || dp[i + 1][j - 1])) {
                dp[i][j] = 1;
                res++;
            }
        }
    }
    return res;
};

分析：时间复杂度为 O(n²)，空间复杂度为 O(n²)。

由于 dp[i][j] 依赖于 dp[i + 1][j - 1]，即左下角位置，可以使用状态压缩将二维 dp 数组优化为一维 dp 数组。

/**
 * @param {string} s
 * @return {number}
 */
var countSubstrings = function(s) {
    const dp = new Array(s.length).fill(0);
    let res = 0;
    for (let i = s.length - 1; i >= 0; i--) {
        for (let j = s.length - 1; j >= i; j--) {
            if (s[i] === s[j] && (j - i <= 1 || dp[j - 1])) {
                dp[j] = 1;
                res++;
            } else {
                dp[j] = 0;
            }
        }
    }
    return res;
};

分析：时间复杂度为 O(n²)，空间复杂度为 O(n)。

题解2：双指针

思路：以 s 中的每个元素为中心，向外扩散寻找回文子串。

/**
 * @param {string} s
 * @return {number}
 */
var countSubstrings = function(s) {
    let res = 0;
    for (let i = 0; i < s.length; i++) {
        // 以 s[i] 为中心向外扩散
        let j = 0;
        while (i + j < s.length && i - j >= 0 && s[i + j] === s[i - j]) {
            res++;
            j++;
        }
        // 以 s[i] 和 s[i + 1] 为中心向外扩散
        j = 0;
        while (i + j + 1 < s.length && i - j >= 0 && s[i + j + 1] === s[i - j]) {
            res++;
            j++;
        }
    }
    return res;
};

分析：时间复杂度为 O(n²)，空间复杂度为 O(1)。

收获

练习使用动态规划法求解子序列问题。