力扣第647题 回文子串 c++ 动态规划 双指针 附Java代码 注释解释版

题目

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 由小写英文字母组成

思路和解题方法 一 动态规划

1. vector<vector<bool>> dp(s.size(),vector<bool>(s.size(),false));：这行代码定义了一个二维布尔类型的动态规划数组dp，用来记录字符串s中从位置i到j的子串是否为回文串。

2. int ans = 0;：初始化一个变量ans用来存储回文子串的数量。

3. for(int i = s.size()-1;i>=0;i--)：从字符串的末尾向前遍历每个字符，作为子串的起始位置。

4. for(int j = i;j<s.size();j++)：遍历以当前i位置字符为起始的所有可能的子串。

5. if(s[i] == s[j] && (j-i<=1||dp[i+1][j-1]))：如果当前子串的两端字符相同，并且长度不超过1，或者去掉两端字符后剩下的子串是回文串（根据dp数组的记录），则认为当前子串是回文串。

6. ans++;：累加回文子串的数量。

7. dp[i][j] = true;：更新dp数组，表示从位置i到j的子串是回文串。

8. 最后返回ans，即为字符串s中回文子串的数量。

复杂度

        时间复杂度:

                O(n*n)

        时间复杂度为O(n^2)，其中n为输入字符串s的长度。这是因为代码中使用了两重循环来遍历所有可能的子串，并在每次循环中进行常数时间的比较和更新操作。

        空间复杂度

                O(n*n)

        至于空间复杂度，由于使用了一个二维动态规划数组dp，其大小为s.size() * s.size()，因此空间复杂度也为O(n^2)。

c++ 代码 1

打印的dp数组：（以“abcba"为样例）

  a  b  c   b  a

class Solution {
public:
    int countSubstrings(string s) {
        // 创建一个二维动态规划数组dp，用于记录子串是否为回文
        vector<vector<bool>> dp(s.size(), vector<bool>(s.size(), false));
        int ans = 0; // 记录回文子串的数量
        for (int i = s.size() - 1; i >= 0; i--) {
            for (int j = i; j < s.size(); j++) {
                // 如果当前字符相等，并且满足回文条件，则更新结果和dp数组
                if (s[i] == s[j] && (j - i <= 1 || dp[i + 1][j - 1])) {
                    ans++; // 回文子串数量加一
                    dp[i][j] = true; // 更新dp数组表示从i到j的子串是回文
                }
            }
        }
        return ans; // 返回回文子串的数量
    }
};

双指针

先看时间空间复杂度对比：（大差不差的区别）

以下是双指针法

思路和解题方法 二 双指针

1. 主函数countSubstrings中，首先初始化变量ans为0，用于存储回文子串的数量。

2. 然后通过一个for循环遍历字符串s的每个字符（下标为i），对于每个字符，分别调用explore函数两次：

   • 第一次调用explore(s, i, i, s.size())：以当前字符为中心，向两边扩展寻找回文子串。
   • 第二次调用explore(s, i, i+1, s.size())：以当前字符和下一个字符为中心，向两边扩展寻找回文子串。

3. 在explore函数中，通过双指针i和j向两边扩展，检查以i和j为中心的回文子串数量。

4. 当i和j位置的字符相等时，i向左移动，j向右移动，并同时增加回文子串数量cnt。

5. 最后返回cnt作为以i和j为中心的回文子串数量。

6. 最后，主函数返回累加的回文子串数量ans。

复杂度

        时间复杂度:

                O(n*n)

       时间复杂度为O(n^2)，其中n为输入字符串s的长度。这是因为在主函数countSubstrings中，通过一个嵌套的循环遍历字符串s的每个字符，并且在explore函数中，利用双指针向两边扩展来判断回文子串，最坏情况下需要O(n)的时间复杂度。

        空间复杂度

                O(1)

        空间复杂度则为O(1)，因为除了存储回文子串数量的变量ans外，算法并未使用额外的空间，因此空间复杂度是常数级的。

c++ 代码 2

class Solution {
public:
    int countSubstrings(string s) {
        int ans = 0; // 初始化回文子串数量为0
        for(int i = 0; i < s.size(); i++) { // 遍历字符串s的每个字符
            ans += explore(s, i, i, s.size()); // 以当前字符为中心，向两边扩展寻找回文子串
            ans += explore(s, i, i + 1, s.size()); // 以当前字符和下一个字符为中心，向两边扩展寻找回文子串
        }
        return ans; // 返回回文子串的总数量
    }

    int explore(const string &s, int i, int j, int n) {
        int cnt = 0; // 记录以i和j为中心的回文子串数量
        while(i >= 0 && j < n && s[i] == s[j]) { // 向两边扩展，直到不是回文串为止
            i--; // 向左移动指针
            j++; // 向右移动指针
            cnt++; // 回文子串数量加一
        }
        return cnt; // 返回回文子串数量
    }
};

附Java代码

1.动态规划

class Solution {
    public int countSubstrings(String s) {
        // 创建一个二维数组dp，dp[i][j]表示从索引i到索引j的子串是否为回文子串
        boolean[][] dp = new boolean[s.length()][s.length()];
        
        int res = 0; // 用于存储回文子串数量的变量
        // 双重循环遍历字符串，i表示起始索引，j表示结束索引
        for (int i = s.length() - 1; i >= 0; i--) {
            for (int j = i; j < s.length(); j++) {
                // 如果当前字符相等，并且满足以下条件之一：
                // 1. j和i相差不超过1，即长度为1或2的子串
                // 2. dp[i+1][j-1]为true，即去掉头尾字符后的子串是回文串
                if (s.charAt(i) == s.charAt(j) && (j - i <= 1 || dp[i + 1][j - 1])) {
                    res++; // 回文子串数量加1
                    dp[i][j] = true; // 标记索引i到索引j的子串为回文子串
                }
            }
        }
        return res; // 返回回文子串数量
    }
}

2.双指针

class Solution {
    public int countSubstrings(String s) {
        int len, ans = 0; // 初始化变量len和ans
        if (s == null || (len = s.length()) < 1) return 0; // 如果输入字符串为空或长度小于1，则直接返回0
        // 总共有2 * len - 1个中心点，因为可以以每个字符为中心，也可以以两个字符之间的空隙为中心
        for (int i = 0; i < 2 * len - 1; i++) {
            // 通过遍历每个回文中心，向两边扩散，并判断是否回文子串
            // 有两种情况，当i为偶数时，回文中心是一个字符；当i为奇数时，回文中心是两个字符之间的空隙
            int left = i / 2, right = left + i % 2; // 根据i的奇偶性确定回文中心的左右位置
            while (left >= 0 && right < len && s.charAt(left) == s.charAt(right)) {
                // 如果当前是一个回文子串，则记录数量
                ans++;
                left--;
                right++;
            }
        }
        return ans; // 返回回文子串数量
    }
}

觉得有用的话可以点点赞，支持一下。

如果愿意的话关注一下。会对你有更多的帮助。

每天都会不定时更新哦  >人<  。