[leetcode]730. Count Different Palindromic Subsequences计数不同的回文子序列的个数

Example 1:

Input: 
S = 'bccb'
Output: 6
Explanation: 
The 6 different non-empty palindromic subsequences are 'b', 'c', 'bb', 'cc', 'bcb', 'bccb'.
Note that 'bcb' is counted only once, even though it occurs twice.

Example 2:

Input: 
S = 'abcdabcdabcdabcdabcdabcdabcdabcddcbadcbadcbadcbadcbadcbadcbadcba'
Output: 104860361
Explanation: 
There are 3104860382 different non-empty palindromic subsequences, which is 104860361 modulo 10^9 + 7.

Note:

• The length of S will be in the range [1, 1000].
• Each character S[i] will be in the set {'a', 'b', 'c', 'd'}.

 

题意：

计数不同的回文子序列的个数

 

Solution1：DP

 

 

 

 

 

 

 

code

/*
Recursion with memoization
Time complexity: O(n^2)
Space complexity: O(n^2)
*/

class Solution {
     private int[][] memo;
    // requirement: "return that number modulo 10^9 + 7"
    private static final int kMod = 1000000007;
    public int countPalindromicSubsequences(String S) {
        int n = S.length();
        memo = new int[n][n];
        return count(S.toCharArray(), 0, n - 1);
    }

    private int count(char[] s, int i, int j) {
        if (i > j) return 0;
        if (i == j) return 1;
        if (memo[i][j] > 0) return memo[i][j];
        // 根据题意，count结果可能很大，用long更保险
        long result = 0;
        // 当前首尾字符相同
        if (s[i] == s[j]) {
            //  count(中间子串解) *2
            result += count(s, i + 1, j - 1) * 2;
            int l = i + 1;
            int r = j - 1;
            while (l <= r && s[l] != s[i]) ++l;
            while (l <= r && s[r] != s[i]) --r;
            // case1: 中间子串的字符中，都不同于当前首尾字符
            if (l > r) result += 2;
            // case2：中间子串的字符中，有1个字符等于当前首尾字符
            else if (l == r) result += 1;
            // case3: 中间子串的2个首尾字符，等于当前首尾字符
            else result -= count(s, l + 1, r - 1);
        }
        // 当前首尾字符不同
        else {
            result = count(s, i, j - 1)
                    + count(s, i + 1, j)
                    - count(s, i + 1, j - 1);
        }
        // to avoid stack overflow
        memo[i][j] = (int)((result + kMod) % kMod);
        return memo[i][j];
    }
}