leetcode730. 统计不同回文子序列

最新推荐文章于 2022-06-19 09:54:41 发布

原创最新推荐文章于 2022-06-19 09:54:41 发布

· 158 阅读

0 ·

版权

文章标签：

#动态规划 #算法 #c++

leetcode 专栏收录该内容

74 篇文章

订阅专栏

给定一个字符串 s，本题要求计算 s 中所有不同的非空回文子序列数量，并对 10^9 + 7 取模。回文子序列是指在删除若干字符后，字符序列与其反转后的序列相同。示例展示了如何计算不同回文子序列个数，并提供了解题思路和动态规划的代码实现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

给定一个字符串 s，返回 s 中不同的非空「回文子序列」个数。

通过从 s 中删除 0 个或多个字符来获得子序列。

如果一个字符序列与它反转后的字符序列一致，那么它是「回文字符序列」。

如果有某个 i , 满足 ai != bi ，则两个序列 a1, a2, … 和 b1, b2, … 不同。

注意：

结果可能很大，你需要对 109 + 7 取模。

示例 1：

输入：s = ‘bccb’
输出：6
解释：6 个不同的非空回文子字符序列分别为：‘b’, ‘c’, ‘bb’, ‘cc’, ‘bcb’, ‘bccb’。
注意：‘bcb’ 虽然出现两次但仅计数一次。
示例 2：

输入：s = ‘abcdabcdabcdabcdabcdabcdabcdabcddcbadcbadcbadcbadcbadcbadcbadcba’
输出：104860361
解释：共有 3104860382 个不同的非空回文子序列，104860361 对 109 + 7 取模后的值。

提示：

1 <= s.length <= 1000
s[i] 仅包含 ‘a’, ‘b’, ‘c’ 或 ‘d’

解题思路：
动态规划：难点在于需要过滤掉重复的。如果不过滤掉重复的，问题就简单了，如果s[i] 和s[j]的值不相等的。那么递推关系就很明确了dp[i][j] = (dp[i + 1][j] + dp[i][j - 1] - dp[i + 1][j - 1] + MOD) % MOD;。如果是相等的，二倍的dp[i + 1][j - 1] + 3即可。但是要求去掉重复的。这种在s[i] == s[j]就需要特殊处理了。如果在区间（i + 1， j - 1)没有出现过s[i] 直接答案加2. 如果出现过，出现一次，那么就是答案加1. 如果出现多次呢？需要求出区间内，(low, hight)这个范围内惠文字符串的数量，总的数量减去这个数量。
代码如下：

class Solution {
public:
    const int MOD = 1e9 + 7;
    int countPalindromicSubsequences(string s) {
        int n = s.size();
        //前缀
        vector<vector<long long>>dp(n, vector<long long>(n, 0));
        vector<vector<int>> next(n, vector<int>(4));//后一个相同元素的位置
        vector<vector<int>> pre(n, vector<int>(4));//前一个相同元素的位置
        for (int i = 0; i < n; i++) {
            dp[i][i] = 1;
        }
        vector<int> pos(4, -1);
        for (int i = 0; i < n; i++) {
            for (int c = 0; c < 4; c++) {
                pre[i][c] = pos[c];
            }
            pos[s[i] - 'a'] = i;
        }
        pos[0] = pos[1] = pos[2] = pos[3] = n;
        for (int i = n - 1; i >= 0; i--) {
            for (int c = 0; c < 4; c++) {
                next[i][c] = pos[c];
            }
            pos[s[i] - 'a'] = i;
        }
        //动态规划 
        for (int len = 1; len < n; ++len) {
            for (int i = 0; i + len < n; ++i) {
                int j = i + len;
                if (len == 1) {
                    dp[i][j] = 2;
                    continue;
                }
                if (s[i] == s[j]) {
                    int low = next[i][s[i] - 'a'];
                    int high = pre[j][s[i] - 'a'];
                    if (low > high) {
                        dp[i][j] = (2 + dp[i + 1][j - 1] * 2 + MOD) % MOD;
                    } else if (low == high) {
                        dp[i][j] = (1 + dp[i + 1][j - 1] * 2 + MOD) % MOD;
                    } else {
                        dp[i][j] = (dp[i + 1][j - 1] * 2 - dp[low + 1][high - 1] + MOD) % MOD;
                    }
                } else {
                    dp[i][j] = (dp[i + 1][j] + dp[i][j - 1] - dp[i + 1][j - 1] + MOD) % MOD;
               }
            }
        }

        return dp[0][n - 1];
    }
};