线性结构 —— 前缀和

【概述】

前缀和是一种及其优秀的线性结构，也是一种重要的思想，能极大的降低区间查询的时间复杂度。

前缀和又分为一维前缀和、二维前缀和，其与差分数组密切相关，关于差分数组：点击这里

【一维前缀和】

假设有一串长度为 n 的序列，再给出 m 次询问，每次询问给出 L、R 两个数，要求求出区间 [L,R] 的和，如果不使用前缀和的话，每次都遍历一遍给出的区间，计算出答案，这样时间复杂度会达到 O(n*m)，极有可能会 TLE，而使用前缀和来做的话，能将时间复杂度降到 O(n+m)，极大的减少了时间。

前缀和的第 i 项就是一个序列前面 i 个数的总和，在一个序列经过 n 次求和次操作后，对于 m 次询问，每次只需要计算 sum[R]-sum[L-1] 即可得到所需的答案。

前缀和求法如下：

sum[0]=0;
for(int i=1;i<=n;i++)
    sum[i]=sum[i-1]+a[i];

对于已求出的前缀和，区间 [L,R] 的和即为：res=sum[R]-sum[L-1]

int query(int L,int R){
    return sum[R]-sum[L-1];
}

对于异或操作，其符合前缀和性质，有： a[l] ^ a[l+1] ^ a[l+2]... ^ a[r] = a[r]，因此，如要求异或和的最大连续子段和，有：

int query(){
    int res=0;
    for(int i=1; i<=n; i++)
        for(int j=i; j<=n; j++)
            res=max(res,sum[j]^sum[i-1]);
    return res;
}

当给出 m 个操作，要求将区间 [L,R] 中的所有元素都加/减 x，再给出 q 个询问求 [L,R] 的和，这个时候就利用上了差分数组，开一个数组 f 作为差分数组，存储每一次的修改操作，最后在求前缀和的时候进行统计，即可得到答案

int n,m,q;
int a[N];
int f[N],sum[N];
void update(int L,int R,int x){
    f[L]+=x;
    f[R+1]-=x;
}
void init(){//求前缀和
    int tot=0;
    for(int i=1;i<=n;i++){//通过差分数组计算新序列
        tot+=f[i];
        a[i]=a[i]+tot;
    }
    for(int i=1;i<=n;i++)
        sum[i]=sum[i-1]+a[i];
}
int query(int L,int R){//查询区间
    return sum[R]-sum[L-1];
}
int main(){
    cin>>n>>m>>q;
    for(int i=1;i<=n;i++)//输入序列
        cin>>a[i];

    while(m--){//m个操作
        int l,r,x;
        cin>>l>>r>>x;
        update(l,r,x);
    }

    init();//获取前缀和

    while(q--){//q次询问
        int l,r;
        cin>>l>>r;
        cout<<query(l,r)<<endl;
    }
    return 0;
}

【二维前缀和】

假设有一个 n*m 大小的矩阵 A，再给出有 q 次询问，每次询问给出 x1、y1、x2、y2 四个数，要求输出以 (x1,y1) 为左上角坐标和以 (x2,y2) 为右下角坐标的子矩阵的所有元素和。 

同一维前缀和一样，如果对于每次询问都进行暴力查询，那么时间复杂度极大，一定会 TLE，此时可以利用二维前缀和来求解。

以上图中 a[3][3]=13 为例，a[3][3] 的前缀和，是以黑框框起来的子矩阵元素之和，从递推的角度来看，sum[3][3]=sum[3][2]+sum[2][3]-sum[2][2]，以此类推，有：sum[i][j]=sum[i][j-1]+sum[i-1][j]-sum[i-1][j-1]+a[i][j]

int sum[N][N];
void init(){
    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++)
            sum[i][j]=sum[i][j-1]+sum[i-1][j]-sum[i-1][j-1]+a[i][j];
}

如上文叙述，每次要查询的答案是上图中黄色的部分，可以看出，黄色=四个区域-(蓝色+绿色)-(蓝色+红色)+蓝色，那么当给出 x1、y1、x2、y2 时，要查询的值即为：res=sum[x2][y2]-sum[x1-1][y2]-sum[x2][y2-1]+sum[x1-1][y-1]

int query(int x1,int y1,int x2,int y2){
    return sum[x2][y2]-sum[x1-1][y2]-sum[x2][y1-1]+sum[x1-1][y1-1];
}

 

与一维前缀和相同，当给出 k 个操作，要求将以 (x1,y1) 为左上角 (x2,y2) 为右上角的子矩阵中的所有元素都加/减 x，再给出 q 个询问子矩阵的和，这个时候就利用上了差分数组，开一个数组 f 作为差分数组，存储每一次的修改操作，最后在求前缀和的时候进行统计，即可得到答案

int n,m,k,q;
int a[N][N];
int sum[N][N];
int f[N][N];
int query(int x1,int y1,int x2,int y2) { //查询
    return sum[x2][y2]-sum[x1-1][y2]-sum[x2][y1-1]+sum[x1-1][y1-1];
}
void update(int x1,int y1,int x2,int y2,int x) { //更新
    f[x1][y1]+=x;
    f[x1][y2+1]-=x;
    f[x2+1][y2+1]+=x;
    f[x2+1][y1]-=x;
}
void init() { //求前缀和
    int tot=0;
    for(int i=1; i<=n; i++) { //通过差分数组计算新序列
        for(int j=1; j<=m; j++) {
            tot+=f[i][j];
            a[i][j]=a[i][j]+tot;
        }
    }
    for(int i=1; i<=n; i++)
        for(int j=1; j<=m; j++)
            sum[i][j]=sum[i][j-1]+sum[i-1][j]-sum[i-1][j-1]+a[i][j];
}
int main() {
    cin>>n>>m>>k>>q;
    for(int i=1; i<=n; i++)
        for(int j=1; j<=m; j++)
            cin>>a[i][j];
    while(k--) { //k次操作
        int x1,y1,x2,y2,x;
        cin>>x1>>y1>>x2>>y2>>x;
        update(x1,y1,x2,y2,x);
    }

    init();//求前缀和

    while(q--) { //q次查询
        int x1,y1,x2,y2;
        cin>>x1>>y1>>x2>>y2;
        int res=query(x1,y1,x2,y2);
    }
    return 0;
}

【例题】

1. 最长配对（51Nod-2494）：点击这里
2. 和为S（51Nod-2518）：点击这里
3. 和为k的倍数（51Nod-2522）：点击这里
4. Splitting Pile（AtCoder-2654）：点击这里
5. Weather（CF-234C）：点击这里
6. Little Xor（CF-252A）(异或前缀和)：点击这里
7. RGB Substring (hard version) （CF-1196D2）(前缀和+区间最小值)：点击这里
8. 01串（51Nod-1391）(前缀和+最长长度)：点击这里
9. 和为k的连续区间（51Nod-1094）(前缀和+连续区间)：点击这里
10. キャンディーとN人の子供 / Children and Candies（AtCoder-2021）(前缀和+线性DP)：点击这里
11. Checker（AtCoder-3876）(二维前缀和)：点击这里
12. 小a的轰炸游戏（2019牛客寒假算法基础集训营 Day1-E）(二维前缀和)：点击这里
13. 海啸（2019牛客寒假算法基础集训营 Day6-E）(二维前缀和+lowbit)：点击这里
14. Table with Letters-2（CF-253D）(二维前缀和+有技巧的枚举)：点击这里
15. 循环数组最大字段和（51Nod-1050）(deque+前缀和)：点击这里
16. Lines（HDU-5124）(pair+前缀和)：点击这里