[NOIP2017模拟]连环

题目描述
惠子说：“连环可解也”。
这说明他是一个破解机关的高手，连连环都能解开，鲁班锁什么的自然不在话下。一位鲁班的后人非常不服气，于是找到惠子，给他出了一道题。
他首先给了惠子一个长度为n的字符串s和一个长度为m的字符串t，现在，他有k个询问，每个询问是给出两个整数 L,R,询问任选一对(i,j)满足 1≤i≤L,n≥j≥R，删去 s 的*i+1,j−1+这个区间的子串，剩下两块拼在一起，求t 在其中的匹配数的期望e。
惠子非常擅长吹逼，但是对数学却搞不太明白，于是他请你来帮他。
为了防止实数的精度误差，你只需要输出 e×L×(n−R+1)

输入格式
第一行一个整数 C，表示数据组数
每组数据，第一行是三个整数 n，m，k
接下来一行字符串表示 s
接下来一行字符串表示 t
接下里 k行，每行两个整数Li,Ri，表示一组询问
C≤5
n≤5×10^4，m≤100，k≤$5×10^4$
1≤Li＜Ri≤n
对于 30%的数据，n≤100,k≤100

输出格式
对于每组询问，输出一行一个整数表示答案

样例数据
输入
1
8 5 4
iamnotsb
iamsb
4 7
3 7
3 8
2 7
输出
1
1
0
0

分析：
【难度】低
【知识点】简单字符串匹配、简单组合计数
*std输出的时候使用了%I64d，在linux 下需要改成%lld
【算法分析】
删去一段之后的匹配分两种，一种是本来就匹配的，删除没有影响他，另一种是本来不匹配，删除之后因为两端连接产生的新匹配。
首先考虑第一种：设t 的某个匹配为(l,r),推一下公式发现若 r≤L，那么这个匹配的贡献为(L−r+1)×(n−R+1)=(L+1)(n−R+1)−r(n−R+1)，那么我们可以预处理一下匹配的 r 的前缀和匹配数的前缀和,就可以 O(1)询问出来了。而若 l≥R，那么贡献是(l−R+1)×L，也类似的弄两个前缀和出来就好。
现在考虑因为删除中间一坨而产生的新匹配，我们考虑把 t 拆开成两个非空部分 t1,t2，显然这一种的总贡献等同于 t1 在[1,L]内的匹配数乘以 t2 在[R,n]内的匹配数，这个也可以预处理一下前缀和，询问的时候枚举拆开的位置就行了。

代码：

#include <stdio.h>
#include <string.h>

typedef long long Long;
typedef unsigned Int;

const int N = 50000;
const int M = 100;
const Int A = 233;

char s[N + 10];
char t[M + 10];
Int hs[N + 10];
Int ht[M + 10];
Int pow[N + 10];

int hit[M + 5][2][N + 5];

Long rig[N + 10];
Long lef[N + 10];
Long numr[N + 10];
Long numl[N + 10];

Int ask(Int * a,int l,int r)
{
    return a[r] - a[l-1] * pow[r-l+1];
}

int main()
{
    freopen("lianhuan.in","r",stdin);
    freopen("lianhuan.out","w",stdout);

    pow[0] = 1;
    for(int i = 1;i <= N;i++)
        pow[i] = pow[i-1] * A;

    int ti = 0;
    scanf("%d",&ti);

    for(int _t = 1;_t <= ti;_t ++)
    {
        memset(hit,0,sizeof(hit));
        memset(rig,0,sizeof(rig));
        memset(lef,0,sizeof(lef));
        memset(numr,0,sizeof(numr));
        memset(numl,0,sizeof(numl));

        int n = 0;
        int m = 0;
        int k = 0;
        scanf("%d%d%d",&n,&m,&k);

        scanf("%s%s",s + 1,t + 1);

        for(int i = 1;i <= n;i++)
            hs[i] = hs[i-1] * A + (Int)s[i];

        for(int i = 1;i <= m;i++)
            ht[i] = ht[i-1] * A + (Int)t[i];

        for(int i = 1;i <= m-1;i++)
        {
            for(int j = 1;j+i-1 <= n;j++)
            {
                if(ask(ht,1,i) == ask(hs,j,j+i-1))
                    hit[i][0][j+i-1] ++;
            }
            for(int j = 1;j+(m-i)-1 <= n;j++)
            {
                if(ask(ht,i+1,m) == ask(hs,j,j+(m-i)-1))
                    hit[i][1][j] ++;
            }
            for(int j = 1;j <= n;j++)
                hit[i][0][j] += hit[i][0][j-1];
            for(int j = n;j >= 1;j--)
                hit[i][1][j] += hit[i][1][j+1];
        }

        for(int i = 1;i+m-1 <= n;i++)
        {
            if(ask(ht,1,m) == ask(hs,i,i+m-1))
            {
                rig[i+m-1] += i+m-1;
                numr[i+m-1] ++;
                lef[i] += i;
                numl[i] ++;
            }
        }

        for(int i = 1;i <= n;i++)
        {
            rig[i] += rig[i-1];
            numr[i] += numr[i-1];
        }
        for(int i = n;i >= 1;i--)
        {
            lef[i] += lef[i+1];
            numl[i] += numl[i+1];
        }

        for(int i = 1;i <= k;i++)
        {
            int L = 0;
            int R = 0;
            scanf("%d%d",&L,&R);

            Long res = 0;
            res += 1LL * (L + 1) * (n - R + 1) * numr[L];
            res -= 1LL * (n - R + 1) * rig[L];
            res += 1LL * (1 - R) * L * numl[R];
            res += 1LL * L * lef[R];

            for(int j = 1;j <= m-1;j++)
                res += 1LL * hit[j][0][L] * hit[j][1][R];
            printf("%I64d\n",res);
        }
    }

    return 0;
}

本题结。