第十一届蓝桥杯 ——子串分值

题目描述
对于一个字符串 $S$，我们定义 $S$ 的分值 $f(S)$ 为 $S$ 中恰好出现一次的字符个数。

例如 $f(“aba”)=1$，$f(“abc”)=3$，$f(“aaa”)=0$。

现在给定一个字符串 $S[0..n-1]$，请你计算对于所有 $S$ 的非空子串 $S[i..j]$ ，$f(S[i..j])$ 的和是多少。

输入格式
输入一行包含一个由小写字母组成的字符串 S。

输出格式
输出一个整数表示答案。

输入样例
ababc

输出样例
21

样例解释

子串 f值
a     1
ab    2
aba   1
abab  0
ababc 1
 b    1
 ba   2
 bab  1
 babc 2
  a   1
  ab  2
  abc 3
   b  1
   bc 2
    c 1

数据范围
对于 20% 的评测用例，$1\le n\le 10$；
对于 40% 的评测用例，$1\le n\le 100$；
对于 50% 的评测用例，$1\le n\le 1000$；
对于 60% 的评测用例，$1\le n\le 10000$；
对于所有评测用例，$1\le n\le 100000$。

---

题解一（超时）
暴力枚举 $O(N^3)$：可得 40% 的分数

解题思路：

1. 枚举区间左端点；
2. 枚举区间右端点；
3. 遍历当前所枚举的区间，累加仅出现一次的字母个数；

unordered_set：自动删去重复元素，使得集合内的元素各不相同；

1. size：返回集合内的元素数量；
2. count：判断某个元素是否在集合中；
3. erase：删去集合中的某个元素；
4. insert：向集合中插入某个元素；

#include <iostream>
#include <unordered_set>
using namespace std;

int main()
{
    string s;
    cin >> s;
    
    int ans = 0;
    for (int l = 0; l < s.size(); l ++)
        for (int r = l; r < s.size(); r ++)
        {
            unordered_set<char> S, T;
            for (int k = l; k <= r; k ++)
                if(S.count(s[k]))
                {
                    S.erase(s[k]);
                    T.insert(s[k]);
                }
                else if(!S.count(s[k]) && !T.count(s[k]))
                {
                    S.insert(s[k]);
                }
            ans += S.size();    
        }
        
    cout << ans << endl;
    return 0;
}

---

题解二（超时）
稍加优化 $O(N^2)$：可得 50% ~ 60% 的分数

#include <iostream>
#include <unordered_set>
using namespace std;

int main()
{
    string s;
    cin >> s;
    
    int ans = 0;
    for (int l = 0; l < s.size(); l ++)
    {
        unordered_set<char> S, T;
        for (int r = l; r < s.size(); r ++)
        {
            if(S.count(s[r]))
            {
                S.erase(s[r]);
                T.insert(s[r]);
            }
            else if(!S.count(s[r]) && !T.count(s[r]))
            {
                S.insert(s[r]);
            }
            ans += S.size();
        }
    }
        
    cout << ans << endl;
    return 0;
}

---

题解三
乘法原理 $O(N)$：

解题思路：

1. 统计每个字母在仅出现一次的情况下，能被多少子串所包含；
2. 用 pre[i] 记录第 i 个字母上一次出现的位置，用 next[i] 记录第 i 个字母下一次出现的位置；
3. 那么往左最多能延伸到 pre[i] + 1，其到第 i 个字母一共有 i - pre[i] 个字母；
4. 同理往右最多能延伸到 next[i] - 1，其到第 i 个字母一共有 next[i] - i 个字母；
5. 二者相乘，就是该字母被不同子串所包含的总次数；

#include <iostream>
using namespace std;

typedef long long LL;

const int N = 100010, M = 150;

string s;
int Pre[N], Next[N], Idx[M];

int main()
{
    cin >> s;
    
    int n = s.size();
    s = ' ' + s;
    
    for (int i = 1; i <= n; i ++)
    {
        Pre[i] = Idx[s[i]];
        Idx[s[i]] = i;
    }
    
    for (int i = 97; i <= 122; i ++) Idx[i] = n + 1;		// 右边界初始化
    
    for (int i = n; i >= 1; i --)
    {
        Next[i] = Idx[s[i]];
        Idx[s[i]] = i;
    }
    
    LL ans = 0;
    for (int i = 1; i <= n; i ++)
        ans += (LL) (i - Pre[i]) * (Next[i] - i);

    cout << ans << endl;
    return 0;
}

---

蓝桥杯C/C++组省赛历年题