在这冷漠的世界里光光哭哭

对于一个子串$abc$，可以容易的求出前$i$位子序列个数，记为$dp[i][a][b][c]$
对于一个子串$ab$，可以容易的求出前$i$位子序列个数，记为$dp[i][a][b]$
对于一个子串$a$，可以容易的求出前$i$位子序列个数，记为$dp[i][a]$

首先考虑$dp[r][a][b][c]-dp[l-1][a][b][c]$，这样得到的序列数量多算了两类。

第一类是$bc$在$[l,r]$内，$a$在$[1,l-1]$内
$[l,r]$内的$bc$序列的数量为$dp[r][a][b]-dp[l-1][a][b]-(dp[r][b]-dp[l-1][b])\times dp[l-1][a]$
第一类的数量为
$$(dp[r][a][b]-dp[l-1][a][b]-(dp[r][b]-dp[l-1][b])\times dp[l-1][a])\times dp[l-1][a]$$
第二类是$c$在$[l,r]$内，$ab$在$[1,l-1]$内
数量为
$$(dp[c][r]-dp[c][l-1])\times dp[a][b][l-1]$$
最后答案为
$$dp[r][a][b][c]-dp[l-1][a][b][c]-((dp[r][a][b]-dp[l-1][a][b]-(dp[r][b]-dp[l-1][b])\times dp[l-1][a])\times dp[l-1][a])-((dp[c][r]-dp[c][l-1])\times dp[a][b][l-1])$$
注意到$dp[n][a][b][c]$可以用$O(n\times 26^2)$的复杂度完成（利用末端点优化掉一维），我们可以离线每组答案的询问$O(n\times 26^2+q\times C)$完成

#include<bits/stdc++.h>
#define ll long long
using namespace std;
struct node
{
    int pos;
    ll val;
};
struct query
{
    int len,pos,id,f,a,b,c;
};
vector<query>v[80005];

ll Q[500005][8];

ll presum[26][26][26];
ll dp[26][26][3];
char ss[4];
char s[80005];
int main()
{
    int n,q;
    scanf("%d%d",&n,&q);
    scanf("%s",s+1);
    for(int i=1;i<=q;i++)
    {
//        printf("q=%d\n",q);
        int l,r;
        scanf("%d%d",&l,&r);
        scanf("%s",ss+1);
//        printf("q=%d\n",q);
        /// 长度为3的前缀和
        v[l-1].push_back({3,5,i,-1,ss[1]-'a',ss[2]-'a',ss[3]-'a'});
        v[r].push_back({3,5,i,1,ss[1]-'a',ss[2]-'a',ss[3]-'a'});
        ///前面2 后面1

        v[l-1].push_back({2,1,i,1,ss[1]-'a',ss[2]-'a',ss[3]-'a'});

        v[r].push_back({1,2,i,1,ss[3]-'a',0,0});
        v[l-1].push_back({1,2,i,-1,ss[3]-'a',0,0});

        ///前面1 后面2

        v[l-1].push_back({1,3,i,1,ss[1]-'a',ss[2]-'a',ss[3]-'a'});

        v[r].push_back({2,4,i,1,ss[2]-'a',ss[3]-'a',0});
        v[l-1].push_back({2,4,i,-1,ss[2]-'a',ss[3]-'a',0});

        v[r].push_back({1,6,i,1,ss[3]-'a',0,0});
        v[l-1].push_back({1,6,i,-1,ss[3]-'a',0,0});

        v[l-1].push_back({1,7,i,1,ss[2]-'a',0,0});
//        printf("q=%d\n",q);
    }

    for(int j=0;j<=25;j++)
        for(int k=0;k<=25;k++)dp[j][k][0]=1;
    for(int i=1;i<=n;i++)
    {

        for(int j=0;j<=25;j++)
        for(int k=0;k<=25;k++)
        {
            presum[j][k][s[i]-'a']+=dp[j][k][2];
            if(s[i]-'a'==k)dp[j][k][2]+=dp[j][k][1];
            if(s[i]-'a'==j)dp[j][k][1]+=dp[j][k][0];
        }
        for(auto [len,pos,id,f,a,b,c]:v[i])
        {
//            printf("len=%d pos=%d id=%d f=%d a=%d b=%d c=%d \n",len,pos,id,f,a,b,c);
            if(len==1)Q[id][pos]+=f*dp[a][0][1];
            else if(len==2)Q[id][pos]+=f*dp[a][b][2];
            else if(len==3)Q[id][pos]+=f*presum[a][b][c];
        }
    }
    for(int i=1;i<=q;i++)printf("%lld\n",Q[i][5]-Q[i][1]*Q[i][2]-Q[i][3]*(Q[i][4]-Q[i][6]*Q[i][7]));

    return 0;
}