统计不同回文子字符串

730. 统计不同回文子字符串

来源： LeetCode730. 统计不同回文子字符串

题目描述

730. 统计不同回文子字符串
给定一个字符串 S，找出 S 中不同的非空回文子序列个数，并返回该数字与 10^9 + 7 的模。

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

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

如果对于某个  i，A_i != B_i，那么 A_1, A_2, ... 和 B_1, B_2, ... 这两个字符序列是不同的。

 

示例 1：

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

输入：
S = 'abcdabcdabcdabcdabcdabcdabcdabcddcbadcbadcbadcbadcbadcbadcbadcba'
输出：104860361
解释：
共有 3104860382 个不同的非空回文子字符序列，对 10^9 + 7 取模为 104860361。

思路分析

统计不同回文字符串
例： cbcacdc
假设dp[i][j] 为字符串[i,j]区间的不同回文字符串
回文字符串一般都要考虑两端
只要确定s[i]与s[j] 和 dp[i+1][j-1] 的关系即可
s[i] != s[j]时 不能将s[i], s[j]加入dp[i+1][j-1]组成更长的回文串
s[i] 与 s[j] 分别加入 dp[i+1][j-1]组成回文串，还要去掉重复计算的部分dp[i+1][j-1] dp[i][j] = dp[i+1][j] + dp[i][j-1] - dp[i+1][j-1] 
s[i] == s[j]的时候麻烦
理解成dp[i][j]已经都组装好了，现在我们给他们戴上个帽子穿上个鞋子，那么改变的和没改变的各double一下
如果区间内没有这个帽子，那么还要加一，区间内没有帽子+鞋子再加一
如果区间内存在帽子和鞋子呢， 就要把已经包装过的减去，因为再包装一次是一样的

- 初始化
长度为1， dp[i][i] = 1
长度为2， 无论两元素是否相等均为2
cac : c = c 内部没有相同元素 dp[i][j] = 2*dp[i+1][j-1] + 2 : (a) (cac) // (c) (cc)
bcacd: b != d dp[i][j] = dp[i+1][j] + dp[i][j-1] - dp[i+1][j-1] 
// cacd : (cac) + (acd) - (ac) = (c) + (a) + (cac) + (a) +(c) + (d) - (a) - (c) -> (c) + (a) + (cac) + (d)
// bcac: (b) + (c) + (a) + (cac)
// cac: (a) (cac) (c)
//  (c) (a) (cac) (b) (d)
cbcacdc : c == c 内部有相同元素 （cac） 与 （cac）再包装

代码

class Solution {
public:
    int countPalindromicSubsequences(string S) {
        // S[i] == S[j] 
        // S[i] != S[j] dp[i][j] = dp[i+1][j] + dp[i][j-1] - dp[i+1][j-1]
        int MOD = 1e9+7;
        vector<vector<long long>> dp(S.size(),vector<long long>(S.size(),0));
        for(int i=0; i<S.size(); ++i) dp[i][i] = 1;
        for(int i=1; i<S.size(); ++i) dp[i-1][i] = 2;
        // 初始化
        for(int r=2; r<S.size(); ++r){
            int j;
            for(int i=0; i+r<S.size(); ++i){
                j = i+r;
                if(S[i] == S[j]){
                    int left = i+1, right = j-1;
                    while(left<j && S[left] != S[i]) ++left;
                    while(right>i && S[right] != S[i]) --right;
                    if(left == right) dp[i][j] = 2*dp[i+1][j-1] + 1;// 仅存在一个相同元素
                    else if(left > right) dp[i][j] = 2*dp[i+1][j-1] + 2;
                    else dp[i][j] = 2*dp[i+1][j-1] - dp[left+1][right-1]; // [left, right]与当前帽子相同不能扣帽子
                }//每一个套一层
                else{
                    dp[i][j] = (dp[i+1][j] + dp[i][j-1] - dp[i+1][j-1]);
                } // 套个帽子穿个鞋去掉多的褂子
                dp[i][j] %= MOD;
                dp[i][j] += dp[i][j] > 0 ? 0:MOD; 
            }
        }
        // 状态转换
        return dp[0][S.size()-1] % MOD;
    }
};

算法分析

内部寻找区域内相同元素的时间为O(N)
外部循环O(N^2)
时间O(N^3)
空间O(N^2)

代码改进

把内部寻找相同元素时间复杂度将为O(1)
外部写一个循环，记录该点后续出现的字符的位置和前面最近出现字符的位置

相似扩展

• 相似题目
• 升级版本

归纳总结

hard题果然是hard题，状态转换难了许多