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.

 class Solution {
     public int countPalindromicSubsequences(String S) {
         Map<String, Set<String>> _seqMap = new HashMap<>();
         return findPalindromesHelper(S, _seqMap).size();
     }

     private Set<String> findPalindromesHelper(String s, Map<String, Set<String>> _seqMap) {
         Set<String> result = _seqMap.get(s);
         if (result != null) {
             return result;
         }
         int len = s.length();
         result = new HashSet<String>();
         if (len < ) {
             return result;
         }
         if (len == ) {
             result.add(s);
             return result;
         }
         result.addAll(findPalindromesHelper(s.substring(, len - ), _seqMap));
         result.addAll(findPalindromesHelper(s.substring(, len), _seqMap));
         if (s.charAt() == s.charAt(len - )) {
             Set<String> subSet = findPalindromesHelper(s.substring(, len - ), _seqMap);
             String head = s.substring(, );
             for (String s1 : subSet) {
                 result.add(head + s1 + head);
             }
             result.add(head + head);
         }
         _seqMap.put(s, result);
         return result;
     }
 }

 class Solution {
     public int countPalindromicSubsequences(String s) {
         int len = s.length();
         int[][] dp = new int[len][len];

         char[] chs = s.toCharArray();
         for (int i = ; i < len; i++) {
             dp[i][i] = ; // Consider the test case "a", "b" "c"...
         }

         for (int distance = ; distance < len; distance++) {
             for (int i = ; i < len - distance; i++) {
                 int j = i + distance;
                 if (chs[i] == chs[j]) {
                     int low = i + , high = j - ;
                     while (low <= high && chs[low] != chs[j]) {
                         low++;
                     }
                     while (low <= high && chs[high] != chs[j]) {
                         high--;
                     }
                     if (low > high) {
                         /*
                          * consider the string from i to j is "a...a" "a...a"... where there is no
                          * character 'a' inside the leftmost and rightmost 'a'
                          *
                          * eg: "aba" while i = 0 and j = 2: dp[1][1] = 1 records the palindrome{"b"},
                          * the reason why dp[i + 1][j - 1] * 2 counted is that we count dp[i + 1][j - 1]
                          * one time as {"b"}, and additional time as {"aba"}. The reason why 2 counted
                          * is that we also count {"a", "aa"}. So totally dp[i][j] record the palindrome:
                          * {"a", "b", "aa", "aba"}.
                          */
                         dp[i][j] = dp[i + ][j - ] *  + ;
                     } else if (low == high) {
                         /*
                          * consider the string from i to j is "a...a...a" where there is only one
                          * character 'a' inside the leftmost and rightmost 'a'
                          *
                          * eg: "aaa" while i = 0 and j = 2: the dp[i + 1][j - 1] records the palindrome
                          * {"a"}. the reason why dp[i + 1][j - 1] * 2 counted is that we count dp[i +
                          * 1][j - 1] one time as {"a"}, and additional time as {"aaa"}. the reason why 1
                          * counted is that we also count {"aa"} that the first 'a' come from index i and
                          * the second come from index j. So totally dp[i][j] records {"a", "aa", "aaa"}
                          */
                         dp[i][j] = dp[i + ][j - ] *  + ;
                     } else {
                         /*
                          * consider the string from i to j is "a...a...a... a" where there are at least
                          * two character 'a' close to leftmost and rightmost 'a'
                          *
                          * eg: "aacaa" while i = 0 and j = 4: the dp[i + 1][j - 1] records the
                          * palindrome {"a", "c", "aa", "aca"}. the reason why dp[i + 1][j - 1] * 2
                          * counted is that we count dp[i + 1][j - 1] one time as {"a", "c", "aa",
                          * "aca"}, and additional time as {"aaa", "aca", "aaaa", "aacaa"}. Now there is
                          * duplicate : {"aca"}, which is removed by deduce dp[low + 1][high - 1]. So
                          * totally dp[i][j] record {"a", "c", "aa", "aca", "aaa", "aaaa", "aacaa"}
                          */
                         dp[i][j] = dp[i + ][j - ] *  - dp[low + ][high - ];
                     }
                 } else {
                     dp[i][j] = dp[i][j - ] + dp[i + ][j] - dp[i + ][j - ]; // s.charAt(i) != s.charAt(j)
                 }
                 dp[i][j] = dp[i][j] <  ? dp[i][j] +  : dp[i][j] % ;
             }
         }
         return dp[][len - ];
     }
 }