1930 长度为 3 的不同回文子序列

题目描述：
给你一个字符串 s ，返回 s 中 长度为 3 的不同回文子序列 的个数。
即便存在多种方法来构建相同的子序列，但相同的子序列只计数一次。
回文 是正着读和反着读一样的字符串。
子序列 是由原字符串删除其中部分字符（也可以不删除）且不改变剩余字符之间相对顺序形成的一个新字符串。
例如，“ace” 是 “abcde” 的一个子序列。

示例 1：
输入：s = “aabca”
输出：3
解释：长度为 3 的 3 个回文子序列分别是：

• “aba” (“aabca” 的子序列)
• “aaa” (“aabca” 的子序列)
• “aca” (“aabca” 的子序列)
  -
  示例 2：
  输入：s = “adc”
  输出：0
  解释：“adc” 不存在长度为 3 的回文子序列。

示例 3：
输入：s = “bbcbaba”
输出：4
解释：长度为 3 的 4 个回文子序列分别是：

• “bbb” (“bbcbaba” 的子序列)
• “bcb” (“bbcbaba” 的子序列)
• “bab” (“bbcbaba” 的子序列)
• “aba” (“bbcbaba” 的子序列)

提示：
3 <= s.length <= 105
s 仅由小写英文字母组成

方法1:
主要思路：解题链接汇总
（1）先统计相同的字符所在的位置；
（2）然后对同一种字符个数大于1的，可以使用该种字符最左边和最右边来个字符作为边界，中间的每个字符都可以组成一个长度为3的回文；
（3）将生成的回文存入哈希中进行去重操作，最后返回哈希的长度；

class Solution {
public:
    int countPalindromicSubsequence(string s) {
        unordered_set<string> st;
        vector<vector<int>> counts(26);
        for(int i=0;i<s.size();i++){
            counts[s[i]-'a'].push_back(i);
        }
        for(int i=0;i<counts.size();i++){
            if(counts[i].size()<2){
                continue;
            }
            string tmp;
            tmp+=s[counts[i][0]];
            tmp+=' ';
            tmp+=s[counts[i].back()];
            for(int j=counts[i][0]+1;j<counts[i].back();j++){
                tmp[1]=s[j];
                st.insert(tmp);
            }
        }
        return st.size();
    }
};

func countPalindromicSubsequence(s string) int {
    mp := make(map[string]struct{},0)
    counts := make([][]int,26)
    for i:=0;i<len(s);i++ {
        counts[s[i]-'a']=append(counts[s[i]-'a'],i)
    }
    for i:=0;i<len(counts);i++ {
        if len(counts[i])<2 {
            continue
        }
        tmp := make([]byte,3)
        tmp[0]=s[counts[i][0]]
        tmp[2]=s[counts[i][len(counts[i])-1]]
        for j:=counts[i][0]+1;j<counts[i][len(counts[i])-1];j++ {
            tmp[1]=s[j]
            mp[string(tmp)]=struct{}{}
        }
    }
    return len(mp)
}