LeetCode 730. Count Different Palindromic Subsequences

原题链接在这里：https://leetcode.com/problems/count-different-palindromic-subsequences/

题目：

Given a string S, find the number of different non-empty palindromic subsequences in S, and return that number modulo 10^9 + 7.

A subsequence of a string S is obtained by deleting 0 or more characters from S.

A sequence is palindromic if it is equal to the sequence reversed.

Two sequences A_1, A_2, ... and B_1, B_2, ... are different if there is some i for which A_i != B_i.

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'}.

题解：

Let dp[i][j] denotes the count of palindromic subsequences of S, i - j inclusive.

If S[i] != S[j], dp[i][j] = dp[i + 1][j] + dp[i][j - 1] - dp[i + 1][j - 1]. Since dp[i + 1][j - 1] is accumlated twice here, it needs to be decreased.

Else, dp[i][j] = 2 * dp[i + 1][j - 1] + 2. e.g. "bccb", for "cc" it has 2 palindromic subsequences "c" and "cc". When adding outer "b", it could be "bcb" and "bccb". That is why it times 2. And it could have "b" and "bb", that is why it adds 2.

It has 2 exceptions, 1 is when middle part has one occurance of "b", like "bcbcb", since "b" is already added when checking "cbc", then outer "b" is duplicate, then dp[i][j] = 2 * dp[i][j] + 1.

The other exception is middle part has more than one occurance of "b". like "bbccbb". Since middle part "bccb" already has "bb", "b", "bcb" and "bccb" added, we don't want to add duplicate.

then dp[i][j] = 2 * dp[i + 1][j - 1] - dp[l + 1][r - 1]. "bb" and "b" are + 2. "bcb" and "bccb" are "dp[l + 1][r - 1]".

l is most left occurance after i of S[i], r is most right occurance before j of S[j].

Time Complexity: O(n ^ 3). n = S.length().

Space: O(n ^ 2).

AC Java:

class Solution {
    public int countPalindromicSubsequences(String S) {
        if(S == null || S.length() == 0){
            return 0;
        }
        
        int mod = 1000000007;
        int n = S.length();
        
        char [] chs = S.toCharArray();
        int [][] dp = new int[n][n];
        
        for(int i = 0; i < n; i++){
            dp[i][i] = 1;
        }
        
        for(int d = 1; d < n; d++){
            for(int i = 0; i < n - d; i++){
                int j = i + d;
                if(chs[i] != chs[j]){
                    dp[i][j] = dp[i + 1][j] + dp[i][j - 1] - dp[i + 1][j - 1];
                }else{
                    int l = i + 1;
                    int r = j - 1;
                    while(l <= r && chs[l] != chs[i]){
                        l++;
                    }
                    
                    while(l <= r && chs[r] != chs[j]){
                        r--;
                    }
                    
                    if(l > r){
                        dp[i][j] = 2 * dp[i + 1][j - 1] + 2;
                    }else if(l == r){
                        dp[i][j] = 2 * dp[i + 1][j - 1] + 1;
                    }else{
                        dp[i][j] = 2 * dp[i + 1][j - 1] - dp[l + 1][r - 1];
                    }
                }
                
                dp[i][j] = dp[i][j] < 0 ? dp[i][j] + mod : dp[i][j] % mod;
            }
        }
        
        return dp[0][n - 1];
    }
}

类似Longest Palindromic Subsequence.