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
Swill be in the range[1, 1000]. - Each character
S[i]will be in the set{'a', 'b', 'c', 'd'}.
這道題給了給了我們一個字符串，讓求出所有的非空回文子序列的個數，雖然這題限制了字符只有四種，但還是按一般的情況來解吧，可以有 26 個字母。說最終結果要對一個很大的數字取余，這就暗示了結果會是一個很大的值，對於這種問題一般都是用動態規划 Dynamic Programming 或者是帶記憶數組 memo 的遞歸來解，二者的本質其實是一樣的。先來看帶記憶數組 memo 的遞歸解法，這種解法的思路是一層一層剝洋蔥，比如 "bccb"，按照字母來剝，先剝字母b，確定最外層 "b _ _ b"，這會產生兩個回文子序列 "b" 和 "bb"，然后遞歸進中間的部分，把中間的回文子序列個數算出來加到結果 res 中，中間的 "cc" 調用遞歸會返回2，兩邊都加上b，會得到 "bcb", "bccb"，此時結果 res 為4。然后開始剝字母c，找到最外層 "cc"，此時會產生兩個回文子序列 "c" 和 "cc"，由於中間沒有字符串了，所以遞歸返回0，最終結果 res 為6，按照這種方法就可以算出所有的回文子序列了。
建立一個二維數組 chars，外層長度為 26，里面放一個空數組。這是為了統計每個字母在原字符串中出現的位置，然后定義一個二維記憶數組 memo，其中 memo[i][j] 表示第i個字符到第j個字符之間的子字符串中的回文子序列的個數，初始化均為0。然后遍歷字符串S，將每個字符的位置加入其對應的數組中，比如對於 "bccb"，那么有：
b -> {0, 3}
c -> {1, 2}
然后在 [0, n] 的范圍內調用遞歸函數，在遞歸函數中，首先判斷如果 start 大於等於 end，返回0。如果當前位置在 memo 的值大於0，說明當前情況已經計算過了，直接返回 memo 數組中的值。否則進行所有字母的遍歷，如果某個字母對應的數組中沒有值，說明該字母不曾在字符串中出現，跳過。然后在字母數組中查找第一個不小於 start 的位置，查找第一個小於 end 的位置，當前循環中，start 為0，end 為4，當前處理字母b，new_start 指向0，new_end 指向3，如果當前 new_start 指向了 end()，或者其指向的位置大於 end，說明當前范圍內沒有字母b，直接跳過，否則結果 res 自增1，因為此時 new_start 存在，至少有個單個的字母b，也可以當作回文子序列，然后看 new_start 和 new_end 如果不相同，說明兩者各指向了不同的b，此時 res 應自增1，因為又增加了一個新的回文子序列 "bb"，下面就是對中間部分調用遞歸函數了，把返回值加到結果 res 中。此時字母b就處理完了，現在處理字母c，此時的 start 還是0，end 還是4，new_start 指向1，new_end 指向2，跟上面的分析相同，new_start 在范圍內，結果自增1，因為加上了 "c"，然后 new_start 和 new_end 不同，結果 res 再自增1，因為加上了 "cc"，其中間沒有字符了，調用遞歸的結果是0，for 循環結束，將 memo[start][end] 的值對超大數取余，並將該值返回即可，參見代碼如下：
解法一：
class Solution { public: int countPalindromicSubsequences(string S) { int n = S.size(); vector<vector<int>> chars(26, vector<int>()); vector<vector<int>> memo(n + 1, vector<int>(n + 1, 0)); for (int i = 0; i < n; ++i) { chars[S[i] - 'a'].push_back(i); } return helper(S, chars, 0, n, memo); } int helper(string S, vector<vector<int>>& chars, int start, int end, vector<vector<int>>& memo) { if (start >= end) return 0; if (memo[start][end] > 0) return memo[start][end]; long res = 0; for (int i = 0; i < 26; ++i) { if (chars[i].empty()) continue; auto new_start = lower_bound(chars[i].begin(), chars[i].end(), start); auto new_end = lower_bound(chars[i].begin(), chars[i].end(), end) - 1; if (new_start == chars[i].end() || *new_start >= end) continue; ++res; if (new_start != new_end) ++res; res += helper(S, chars, *new_start + 1, *new_end, memo); } memo[start][end] = res % int(1e9 + 7); return memo[start][end]; } };
我們再來看一種迭代的寫法，使用一個二維的 dp 數組，其中 dp[i][j] 表示子字符串 [i, j] 中的不同回文子序列的個數，初始化 dp[i][i] 為1，因為任意一個單個字符就是一個回文子序列，其余均為0。這里的更新順序不是正向，也不是逆向，而是斜着更新，對於 "bccb" 的例子，其最終 dp 數組如下，可以看到其更新順序分別是紅-綠-藍-橙。
b c c b
b 1 2 3 6 c 0 1 2 3 c 0 0 1 2 b 0 0 0 1
這樣更新的好處是，更新當前位置時，其左，下，和左下位置的 dp 值均已存在，而當前位置的 dp 值需要用到這三個位置的 dp 值。觀察上面的 dp 數組，可以發現當 S[i] 不等於 S[j] 的時候，dp[i][j] = dp[i][j - 1] + dp[i + 1][j] - dp[i + 1][j - 1]，即當前的 dp 值等於左邊值加下邊值減去左下值，因為算左邊值的時候包括了左下的所有情況，而算下邊值的時候也包括了左下值的所有情況，那么左下值就多算了一遍，所以要減去。而當 S[i] 等於 S[j] 的時候，情況就比較復雜了，需要分情況討論，因為不知道中間還有幾個和 S[i] 相等的值。舉個簡單的例子，比如 "aba" 和 "aaa"，當 i = 0, j = 2 的時候，兩個字符串均有 S[i] == S[j]，此時二者都新增兩個子序列 "a" 和 "aa"，但是 "aba" 中間的 "b" 就可以加到結果 res 中，而 "aaa" 中的 "a" 就不能加了，因為和外層的單獨 "a" 重復了。我們的目標就要找到中間重復的 "a"。所以讓 left = i + 1, right = j - 1，然后對 left 進行 while 循環，如果 left <= right, 且 S[left] != S[i] 的時候，left 向右移動一個；同理，對 right 進行 while 循環，如果 left <= right, 且 S[right] != S[i] 的時候，left 向左移動一個。這樣最終 left 和 right 值就有三種情況：
1. 當 left > righ 時，說明中間沒有和 S[i] 相同的字母了，就是 "aba" 這種情況，那么就有 dp[i][j] = dp[i + 1][j - 1] * 2 + 2，其中 dp[i + 1][j - 1] 是中間部分的回文子序列個數，為啥要乘2呢，因為中間的所有子序列可以單獨存在，也可以再外面包裹上字母a，所以是成對出現的，要乘2。加2的原因是外層的 "a" 和 "aa" 也要統計上。
2. 當 left = right 時，說明中間只有一個和 S[i] 相同的字母，就是 "aaa" 這種情況，那么有 dp[i][j] = dp[i + 1][j - 1] * 2 + 1，其中乘2的部分跟上面的原因相同，加1的原因是單個字母 "a" 的情況已經在中間部分算過了，外層就只能再加上個 "aa" 了。
3. 當 left < right 時，說明中間至少有兩個和 S[i] 相同的字母，就是 "aabaa" 這種情況，那么有 dp[i][j] = dp[i + 1][j - 1] * 2 - dp[left + 1][right - 1]，其中乘2的部分跟上面的原因相同，要減去 left 和 right 中間部分的子序列個數的原因是其被計算了兩遍，要將多余的減掉。比如說對於 "aabaa"，當檢測到 S[0] == S[4] 時，是要根據中間的 "aba" 的回文序列個數來計算，共有四種，分別是 "a", "b", "aa", "aba"，將其分別在左右兩邊加上a的話，可以得到 "aaa", "aba", "aaaa", "aabaa"，我們發現 "aba" 出現了兩次了，這就是要將 dp[2][2] (left = 1, right = 3) 減去的原因。
參見代碼如下：
解法二：
class Solution { public: int countPalindromicSubsequences(string S) { int n = S.size(), M = 1e9 + 7; vector<vector<int>> dp(n, vector<int>(n, 0)); for (int i = 0; i < n; ++i) dp[i][i] = 1; for (int len = 1; len < n; ++len) { for (int i = 0; i < n - len; ++i) { int j = i + len; if (S[i] == S[j]) { int left = i + 1, right = j - 1; while (left <= right && S[left] != S[i]) ++left; while (left <= right && S[right] != S[i]) --right; if (left > right) { dp[i][j] = dp[i + 1][j - 1] * 2 + 2; } else if (left == right) { dp[i][j] = dp[i + 1][j - 1] * 2 + 1; } else { dp[i][j] = dp[i + 1][j - 1] * 2 - dp[left + 1][right - 1]; } } else { dp[i][j] = dp[i][j - 1] + dp[i + 1][j] - dp[i + 1][j - 1]; } dp[i][j] = (dp[i][j] < 0) ? dp[i][j] + M : dp[i][j] % M; } } return dp[0][n - 1]; } };
討論：這道題確實是一道很難的題，和它類似的題目還有幾道，雖然那些題有的還有非 DP 解法，但是 DP 解法始終是核心的，也是我們最應該掌握的方法。首先要分清子串和子序列的題，個人感覺子序列要更難一些。在之前那道 Longest Palindromic Subsequence 中要求最長的回文子序列，需要逆向遍歷 dp 數組，當 s[i] 和 s[j] 相同時，長度為中間部分的 dp 值加2，否則就是左邊值和下邊值中的較大值，因為是子序列，不匹配就可以忽略當前字符。而對於回文子串的問題，比如 Longest Palindromic Substring 和 Palindromic Substrings，一個是求最長的回文子串，一個是求所有的回文子串個數，他們的 dp 定義是看子串 [i, j] 是否是回文串，求最長回文子串就是維護一個最大值，不停用當前回文子串的長度更新這個最大值，同時更新最大值的左右邊界。而求所有回文子串的個數就是如果當前 dp[i][j] 判斷是回文串，計數器就自增1。而判斷當前 dp[i][j] 是否是回文串的核心就是 s[i]==s[j]，且 i，j 中間沒有字符了，或者中間的 dp 值為 true。
Github 同步地址：
https://github.com/grandyang/leetcode/issues/730
類似題目：
Longest Palindromic Subsequence
參考資料：
https://leetcode.com/problems/count-different-palindromic-subsequences/