Leetcode730. 不同回文子串数

这道题的解法简直堪称天才。
给定字符串S长度在[1, 1000]，字符属于集合[‘a’, ‘b’, ‘c’, ‘d’]，定义回文子串为删去其中0个或更多个字符得到的回文字符串。求不同的回文子串数？(mod 1000000007)
如字符串’abcdabcdabcdabcdabcdabcdabcdabcddcbadcbadcbadcbadcbadcbadcbadcba’的回文子串数mod1000000007为104860361

如果要找出所有不重复的回文子串，那么长度为1000的字符串有4^1000-1个子串，大大超出了内存的容量。且判定是否回文花费更多的时间。直接上评论区的代码：

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

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

        for(int distance = 1; distance < len; distance++){
            for(int i = 0; i < len - distance; i++){
                int j = i + distance;
                if(chs[i] == chs[j]){
                    int low = i + 1;
                    int high = j - 1;

              /* Variable low and high here are used to get rid of the duplicate*/

                    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 + 1][j - 1] * 2 + 2;  
                    } 
                    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 + 1][j - 1] * 2 + 1;  
                    }
                    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 + 1][j - 1] * 2 - dp[low + 1][high - 1]; 
                    }
                }
                else{
                    dp[i][j] = dp[i][j - 1] + dp[i + 1][j] - dp[i + 1][j - 1];  //s.charAt(i) != s.charAt(j)
                }
                dp[i][j] = dp[i][j] < 0 ? dp[i][j] + 1000000007 : dp[i][j] % 1000000007;
            }
        }

        return dp[0][len - 1];
    }
}

以及评论区的优化：
A minor optimization, preprocess the string and keep rightNext and leftNext in two arrays of int.
For every dp[i][j], we do not have to calculate low and high which costs O(n).
The following optimization can cut the time complexity from O(n ^ 3) to O(n ^ 2)

int countPalindromicSubsequences(string S) {
        int n=S.size();
        long long mod=1e9+7;
        vector<vector<long long>> dp(n,vector<long long> (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+len<n;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+1][j]+dp[i][j-1]-dp[i+1][j-1];
                
                dp[i][j] = dp[i][j] < 0? dp[i][j] + mod:dp[i][j]% mod;
            }
        }
        return (int)dp[0][n-1];
    }

变成JAVA代码：

public int countPalindromicSubsequences(String S) {
        int n = S.length();
        char[] s = S.toCharArray();
        int[] lastPos = new int[4], leftNext = new int[n], rightNext = new int[n];
        for (int i = 0; i < 4; i++) {
            lastPos[i] = -1;
        }
        for (int i = 0; i < n; i++) {
            int c = s[i] - 'a';
            leftNext[i] = lastPos[c];
            lastPos[c] = i;
        }
        for (int i = 0; i < 4; i++) {
            lastPos[i] = -1;
        }
        for (int i = n - 1; i >= 0; i--) {
            int c = s[i] - 'a';
            rightNext[i] = lastPos[c];
            lastPos[c] = i;
        }
        int[][] re = new int[n][n];
        for (int i = 0; i < n - 1; i++) {
            re[i][i] = 1;
            re[i][i + 1] = 2;
        }
        re[n - 1][n - 1] = 1;
        for (int x = 2; x < n; x++) {
            for (int i = 0; i + x < n; i++) {
                int j = x + i, r = rightNext[i], l = leftNext[j];
                if (s[i] != s[j]) {
                    re[i][j] = re[i + 1][j] + re[i][j - 1] - re[i + 1][j - 1];
                }
                else {
                    if (r == -1 || r == j) {
                        re[i][j] = 2 * re[i + 1][j - 1] + 2;
                    }
                    else {
                        if (r == l) {
                            re[i][j] = 2 * re[i + 1][j - 1] + 1;
                        }
                        else {
                            re[i][j] = 2 * re[i + 1][j - 1] - re[r + 1][l - 1];
                        }
                    }
                }
                re[i][j] = Math.floorMod(re[i][j], 1000000007);
            }
        }
        return re[0][n - 1];
    }

这种题只有天才才能自己想出来解法