LeetCode 730. Count Different Palindromic Subsequences (区间DP)

题意

给一个字符串S,求它所有子序列不同非空回文串的数量。字符串由 'a' 'b' 'c' 'd' 四个字母组成。

 

由于题目要求的是不同回文串。 abba 的回文串子序列为 a,b,aba,abba 其中 aba 只能算一次。

 

最近做 区间DP 的题,习惯起手写

for (int l = 0; l < n; l++) {
    for (int s = 0; s + l < n; s++) {
        int e = s + l;
        .....
    }
}    

外层枚举区间长度,内层枚举区间起始位置。

 

设 dp[i][j] 表示  S[i...j] 子序列中包含的回文串的数量。

 

解法1、枚举回文串第一个字母

设回文串第一个字母是 a 则最后一个字母也要是 a 然后找到在区间 [s,t] 中第一个和最后一个 a 的位置 x 和 y ,则,首字母为 a 的回文串个数为 dp[x-1][y+1] 

因为,如果使用的不是两边的 a 而是内部的 a 作为边界,能发现内部 a 做边界组成的回文串 两边的 a 做边界时都组成。

最后再用两边的 a 组成 aa 以及 单个 a。当范围内只存在一个 a 时,则能贡献的子串只有 1 个。

 

很难受的是直接递推超时了,递归才勉强能过。。。

class Solution {
public:
    int countPalindromicSubsequences(string S) {
        // dp[i][j] 表示 s[i...j] 包含的子序列个数
        int n = S.size();
        vector<vector<int>> pos(4, vector<int>());
        vector<vector<int>> dp(n, vector<int>(n, 0));
        for (int i = 0; i < n; i++) {
            pos[S[i] - 'a'].push_back(i);
        }
        return dfs(S, pos, dp, 0, n - 1);
    }
    int dfs(string &S, vector<vector<int>> &pos, vector<vector<int>> &dp, int s, int t) {
        if (s + 1 >= t) return t - s + 1;
        if (dp[s][t]) return dp[s][t];
        int ans = 0;
        for (int i = 0; i < 4; i++) {
            if (pos[i].empty()) continue;
            auto first_pos = lower_bound(pos[i].begin(), pos[i].end(), s);
            auto end_pos = upper_bound(pos[i].begin(), pos[i].end(), t) - 1;
            if (first_pos == pos[i].end() || *first_pos > t) continue;
            int f = *first_pos, e = *end_pos;
            ans = (ans + 1) % 1000000007;
            if (f != e) ans = (ans + 1) % 1000000007;
            if (f + 1 < e) {
                ans = (ans + dfs(S, pos, dp, f + 1, e - 1)) % 1000000007;
            }
        }
        return dp[s][t] = ans;
    }
};

 

解法2 (https://leetcode.com/problems/count-different-palindromic-subsequences/discuss/109507/Java-96ms-DP-Solution-with-Detailed-Explanation

求 S[s..e] 的回文串数

当 S[s] != S[e] 时,可得公式

dp[s][e] = dp[s+1][e] + dp[s][e-1] - dp[s+1][e-1];

即 (包含s + 两边都不含的) 和 (包含e+ 两边都不含的)- 两边都不含的

 

当 S[s] == S[e] 时 还用上面的公式会出现重复。

比如 aaa ,计算 dp[0][2] 时 ,dp[0][1] 包含 (aa) 和 dp[1][2] 包含的 aa 重复但是没有被减去。

而如果想要减去重复部分,就要找到和边界位置相同的字母。假设边界字母是 a,

 

当没有和边界位置相同的字母, dp[s][e] = dp[s+1][e-1](两边都不含的)+ dp[s+1][e-1](两边都不含的 + 两边的字母)+ 1 (两边的字母组成 aa) + 1 (单个首字母 a)

当存在和边界位置相同的字母,且只有一个,dp[s][e] = dp[s+1][e-1](两边都不含的)+ dp[s+1][e-1](两边都不含的 + 两边的字母)+ 1 (两边的字母组成 aa)

当存在和边界位置相同的字母,且有多个(2个及以上) 中间的组成的,可能会和中间的a加上边界之后重复,比如 a(aaa)a 中间组成a aa aaa 加上两边的a 就变成了 aaa aaaa aaaaa 那么 aaa就重复计算了,找到除了边界的两个a,最外层的两个a,设位置是 low 和 high 那么,dp[low+1][high-1] 中所有子序列和low high 组成的回文串与和s e 组成的回文串都会重复。所以要减去dp[low+1][high-1]。dp[s][e] = dp[s+1][e-1] * 2 - dp[low + 1][high - 1]; 

 

其实我也不是很懂。。。。瞎写的。。。真的好难啊。。。。 

class Solution {
public:
    int countPalindromicSubsequences(string S) {
        int n = S.size();
        int dp[n][n];
        int mod = 1e9 + 7;
        for (int l = 0; l < n; l++) {
            for (int s = 0; s + l < n; s++) {
                int e = s + l;
                if (l <= 1) {
                    dp[s][e] = l + 1;
                } else if (S[s] == S[e]) {
                    int low = s + 1, high = e - 1;
                    // 寻找最近的和 S[s](S[e]) 相同的字母的位置
                    while (low <= high && S[low] != S[e]) low++;
                    while (high >= low && S[high] != S[e]) high--;
                    
                    if (low > high) dp[s][e] = dp[s+1][e-1] * 2 + 2;
                    else if (low == high) dp[s][e] = dp[s+1][e-1] * 2 + 1;
                    else dp[s][e] = dp[s+1][e-1] * 2 - (low + 1 < high ? dp[low + 1][high - 1] : 0);
                } else {
                    dp[s][e] = dp[s+1][e] + dp[s][e-1] - dp[s+1][e-1];
                }
                dp[s][e] = (dp[s][e] % mod + mod) % mod;
            }
        }
        return dp[0][n - 1];
    }
};

 

posted @ 2020-04-15 14:15  我不吃饼干呀  阅读(189)  评论(0编辑  收藏  举报