python/TangDou/JiShuanKe/2023-03-10/T3668.md

## [计蒜客 $T3668$ $Eye$ $of$ $the$ $Storm$](https://www.jisuanke.com/problem/T3668)
### 一、题目描述
云浅来到了风暴的中心。这里漂浮着一个长为 $n$ 的，由小写字母组成的字符串 $S$。**字符串的下标从 $1$ 开始。**

想要逃出风暴，就需要回答一些询问。

每次询问会给出一对正整数 $l,r$ 和一个字符串 $T$，云浅需要回答 $S_{l\cdots r}$ 这段子串内有多少个子序列是 $T$。**这里保证 $T$ 的长度为 $2$。**

形式化地，你需要求出有多少对 $(i,j)$ 满足 $l\le i<j\le r$，使得 $S_i=T_1,S_j=T_2$。

现在云浅预测出了风暴在接下来 $q$ 个时刻内的询问，你需要帮她求出每个询问的答案。

### 输入格式

第一行两个正整数 $n,q$。

第二行一个长为 $n$ 的字符串 $S$。

接下来 $q$ 行，每行会给出两个正整数 $l,r$ 和一个字符串 $T$，表示云浅需要回答的询问。保证 $|T|=2$。

### 输出格式

对于每次询问，输出一行一个正整数表示答案。

### 数据范围

对于 $100\%$ 的数据，$1\le n,q\le 2\times 10^5,1\le l\le r\le n,S,T$ 中只含小写英文字母，$|T|=2$。

| 测试点编号  |        $n$         |        $q$         |        其他         |
| :---------: | :----------------: | :----------------: | :-----------------: |
|  $1\sim 4$  |     $\le 100$      |     $\le 100$      |         无          |
|  $5\sim 8$  |     $\le 5000$     |     $\le 5000$     |         无          |
| $9\sim 10$  |     $\le 10^5$     |     $\le 10^5$     | 所有的 $S_i$ 均相同 |
| $11\sim 12$ |     $\le 10^5$     |      $\le 3$       |         无          |
| $13\sim 16$ |     $\le 10^5$     |     $\le 10^5$     |         无          |
| $17\sim 20$ | $\le 2\times 10^5$ | $\le 2\times 10^5$ |         无          |

<div style="page-break-after: always"></div>

### 二、思路
#### 方法一
暴力循环 $[l,r]$，判断是否满足题意的数量，复杂度 $O(n^2q)$

#### 方法二
对于上面的方法，显然，其实我们可以只枚举有多少个满足 $S_j=T_2$，那么有多少个 $i$
 满足 $S_i=T_1$ 是可以用前缀和预处理后 $O(1)$ 算出来的。复杂度 $O(nq)$

#### 方法三
这种方法是对方法二的一种小优化。

我们在枚举有多少个满足 $S_j=T_2$
 时，我们其实是可以把 $S_i$ 按字母分成$26$类，在每一类中分别枚举的，这个过程可以用`vector`辅助实现。

#### 方法四
我们对方法三进行优化。

我们既然已经把 $S_i$ 分类了，而我们要求的是 $[l,r]$ 区间，我们就可以对分类后的 $S_i$ 作个前缀和，然后二分即可。复杂度 $O(qlogn)$

实现上有一些小细节要注意

### 三、$STL$二分版本
```cpp {.line-numbers}
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;

int n, m;              // n个长度的原串，m个询问
char S[N];             // 原串
vector<int> p[26];     // 记录每个字符出现的位置,比如'a'出现在位置1,3,5,...
vector<int> f[26][26]; // 三维数组，从谁,二维：到谁，三维：第几次出现,值：有多少个从谁
int s[N][26];          // 分类前缀和

// 使用STL版本的lower_bound,upper_bound
int main() {
    freopen("ridge.in", "r", stdin);
    freopen("ridge.out", "w", stdout);

    cin >> n >> m >> (S + 1);
    /* (1)因为题目数据范围很大，只能用O(NlogN)的时间复杂度(或更低)才能过掉，所以在输入数据时，必须千方百计的预处理提高性能
       (2)从最后询问的问题来思考，设原串为S,开始字符为x、结束字符为y:
            ① 预处理出S中每个字符出现的位置p[],在询问时可以只枚举有用的位置,例：p[0]={2,4} 表示'a'出现在2,4两个位置。
            ② 预处理出S中每个字符出现的次数s[],可以用前缀和,例：s[10][0]=3 表示在S的前10个字符中，'a'字符出现了3次。
            只有上面两个预处理出的数组还不行，因为串中可能多次出现a和b,但有些a在b后面，直接使用①②是不对的。
            ③ 预处理出：每当y出现时，记录前面已经出现过了多少个x,用数组vector<int> f[][][]来表示:
                第一维代表是26个可能的来源字符x
                第二维代表是26个可能的终止字符y
                第三维代表是:第一次出现，第二次出现,....
                值：x之前出现次数
            ④ 以f[][][]为基础数据，再次三层循环累加起来的值，表示：第k次出现时，前k个y与前面所有x的配对数量，是一个累加前缀和概念。
     */
    for (int i = 1; i <= n; i++) {
        int y = S[i] - 'a'; // 当前字符y
        for (int x = 0; x < 26; x++) {
            s[i][x] = s[i - 1][x];
            f[x][y].push_back(s[i][x]); // x是肯定有的，每回26个，y是因为看到了当前的字符y。换句话说：就是y出来一次，就push_back了26个x的统计数据
        }
        p[y].push_back(i); // 字符y出现在i这个位置上
        s[i][y]++;         // 前i个字符中，字符y出现的次数增加了1个
    }

    // 计算区间前缀和
    for (int i = 0; i < 26; i++)                          // 从字符i
        for (int j = 0; j < 26; j++)                      // 到字符j
            for (int k = 1; k < (int)f[i][j].size(); k++) // 有多条记录
                f[i][j][k] += f[i][j][k - 1];             // 生成前缀和

    while (m--) {
        int l, r;
        string t;
        cin >> l >> r >> t;

        int x = t[0] - 'a', y = t[1] - 'a';
        int ql = lower_bound(p[y].begin(), p[y].end(), l) - p[y].begin();     // y的左边界
        int qr = upper_bound(p[y].begin(), p[y].end(), r) - p[y].begin() - 1; // y的右边界
        if (ql > qr) {                                                        // 如果没有找到y，输出0
            cout << 0 << endl;
            continue;
        }
        int cnt = qr - ql + 1; // y的个数
        // 两层前缀和
        // 以y的右边界结尾，计算y_右与前面所有x的配对数量=f[x][y][qr]
        // 以y的左边界结尾，计算y_右与前面所有x的配对数量=f[x][y][ql - 1]
        // 两者的差，还需要继续减去前l-1个中存在的x与[l,r]区间内的y的配对关系数量
        // 需要注意的是：因为使用的是vector,下标从0开始，如果直接使用ql-1可能会有下标为负数的风险，需要判断一下
        cout << f[x][y][qr] - (ql == 0 ? 0 : f[x][y][ql - 1]) - s[l - 1][x] * cnt << endl;
    }
    return 0;
}
```

### 四、手写二分版本
```cpp {.line-numbers}
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;

int n, m;
char S[N];
vector<int> p[26];
vector<int> f[26][26];
int s[N][26];

int lower_bound(vector<int> q, int l, int r, int x) {
    while (l < r) {
        int mid = (l + r) >> 1;
        if (q[mid] >= x)
            r = mid;
        else
            l = mid + 1;
    }
    return l;
}
int upper_bound(vector<int> q, int l, int r, int x) {
    while (l < r) {
        int mid = (l + r) >> 1;
        if (q[mid] > x)
            r = mid;
        else
            l = mid + 1;
    }
    return l;
}

// 使用手写版本的lower_bound,upper_bound
int main() {
    freopen("ridge.in", "r", stdin);
    freopen("ridge.out", "w", stdout);

    cin >> n >> m >> (S + 1);

    for (int i = 1; i <= n; i++) {
        int y = S[i] - 'a';
        for (int x = 0; x < 26; x++) {
            s[i][x] = s[i - 1][x];
            f[x][y].push_back(s[i][x]);
        }
        p[y].push_back(i);
        s[i][y]++;
    }
    for (int i = 0; i < 26; i++)
        for (int j = 0; j < 26; j++)
            for (int k = 1; k < (int)f[i][j].size(); k++)
                f[i][j][k] += f[i][j][k - 1];

    while (m--) {
        int l, r;
        string t;
        cin >> l >> r >> t;

        int x = t[0] - 'a', y = t[1] - 'a';
        int ql = lower_bound(p[y], 0, (int)p[y].size(), l);
        int qr = upper_bound(p[y], 0, (int)p[y].size(), r) - 1;
        if (ql > qr) {
            cout << 0 << endl;
            continue;
        }
        int cnt = qr - ql + 1;
        cout << f[x][y][qr] - (ql == 0 ? 0 : f[x][y][ql - 1]) - s[l - 1][x] * cnt << endl;
    }
    return 0;
}
```