子串简写（第十四届蓝桥杯CB）

题目描述：

程序猿圈子里正在流行一种很新的简写方法：

对于一个字符串，只保留首尾字符，将首尾字符之间的所有字符用这部分的长度代替。

例如 internationalization 简写成 i18n，Kubernetes 简写成 K8s，Lanqiao 简写成 L5o 等。

在本题中，我们规定长度大于等于 K 的字符串都可以采用这种简写方法（长度小于 K 的字符串不配使用这种简写）。

给定一个字符串 S和两个字符 c1 和 c2，请你计算 S 有多少个以 c1 开头 c2 结尾的子串可以采用这种简写？

输入格式

第一行包含一个整数 K。

第二行包含一个字符串 S 和两个字符 c1 和 c2。

输出格式

一个整数代表答案。

数据范围

对于 20% 的数据，2≤|S|≤10000。
对于 100% 的数据，2≤|S|≤5*10^5。S只包含小写字母。c1 和 c2 都是小写字母。
|S| 代表字符串 S的长度。

输入样例：

c​
4abababdb a b​

输出样例：

6

样例解释

符合条件的子串如下所示，中括号内是该子串

[abab]abdb
[ababab]db
[abababdb]
ab[abab]db
ab[ababdb]
abab[abdb] 

代码(一)如下：

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
#include <vector>


void check()
{
    string s;
    vector<int>va,vb;
    char ca,cb;
    int n;
    cin>>n;
    cin>>s;
    cin>>ca>>cb;
    long long res=0;
    for(int i=0;i<s.size();++i)
  {      if(s[i]==ca)va.push_back(i);
         if(s[i]==cb)vb.push_back(i);
      
  }

    for (int i = 0; i < va.size(); i ++)
    {
        int x = va[i];
        int X = x + n - 1;
        int l = 0, r = vb.size() - 1;
        while (l < r)
        {
            int mid = l + r >> 1;
            if(vb[mid] >= X) r = mid;
            else l = mid + 1;
        }
        if(vb[l] >= X) res += vb.size() - l;
    }
    cout << res << endl;
}
int main()
{
    check();
    return 0;
}

思路：

本题我们还是先观察一下数据的范围，为5*10^5,那么我们很明显不能用O(n^2)的算法来解决这一题，因为这将会超时，所以我们最多只能用O(nlogn)的复杂度来解决这一题，那么我们该怎么写呢？

我们可以用两个数组来记录C1和C2的下标，然后通过下标的差值来判断是否符合条件，由于不知道C1和C2的数量，所以我们用vector来存下标。这时候遍历数组用了O(n)的时间复杂度，那么我们剩下的只有O(logn)，O(logn)的算法我们想到的是二分，然后我们发现这个下标正好是按照顺序存的下标，正好符合二分的条件。

所以整个的思路是：

先用两个容器来存C1和C2的下标，然后遍历C1的容器，然后在判断一下C2中有多少个大于当前C1下标+K的下标，然后最后再加上去就行了。

这里我们要是知道C++中的STL中的upper_bound()

我们可以直接使用该STL，由于该函数的底层是利用二分的方法，所以我们不必担心超时的问题

代码二：

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
#include <vector>


void check()
{
    string s;
    vector<int>va,vb;
    char ca,cb;
    int n;
    cin>>n;
    cin>>s;
    cin>>ca>>cb;
    long long res=0;
    for(int i=0;i<s.size();++i)
      { 
     if(s[i]==ca)va.push_back(i);
         if(s[i]==cb)vb.push_back(i);
        }
        for(auto x:va)
        {
            int pos=vb.end()-upper_bound(vb.begin(),vb.end(),x+n-2);
            if(pos!=-1)
            res+=pos;
        }
        cout<<res<<endl;
}
int main()
{
    check();
    return 0;
}

思路：

我们这里能否再继续优化呢？能否将时间更加优化呢？事实是可以的，我们可以将O(logn)给优化掉，我们可以从第K个字符开始遍历，用cnt记录C1出现的次数，用ans记录结果，当i-k+1为C1的时候，我们需要将cnt++，接下来我们每次遍历到C2的时候，就将ans加上cnt。

那么我们需要判断这个算法是对的，怎么判断呢，我们假设第i个为C2，这时候前i-k+1有cnt个C1，由于中间的差值为k，所以前面的i-k+1中的cnt的C1都可以和第i个字符匹配。

代码三：

#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 500010;
int n, k;
char a, b, s[N];
int main() {
    cin >> k >> s + 1 >> a >> b;
    n = strlen(s + 1);
    long long ans = 0;
    int cnt = 0;
    for (int i = k; i <= n; i ++ ) {
        if (s[i - k + 1] == a) cnt ++ ;
        if (s[i] == b) ans += cnt;
    }
    cout << ans;
    return 0;
}

至此，整个题解完毕！