前缀和与差分

前缀和

  一个长度为n的数组a[0]-a[n-1],它的前缀和sum[i]等于a[0]-a[i]的和。例如，sum[0]=a[0],sum[1]=a[0]+a[1],sum[2]=a[0]+a[2],等等。
  利用递推，可以在O(n)时间内求得所有前缀和：sum[i]=sum[i-1]+a[i]。
  如果预计算出前缀和，就能利用它快速计算出数组中任意区间a[i]-a[j]的和，即a[i]+a[i+1]+…+a[j-1]+a[j]=sum[j]-sum[i-1]。
  这说明复杂度为O(n)的区间和计算优化到了O(1)的前缀和计算。
  前缀和的一个应用是差分，差分是前缀和的逆运算。

一维前缀和

问题描述

输入一个长度为 n的整数序列。
接下来再输入 m 个询问，每个询问输入一对 l,r。
对于每个询问，输出原序列中从第 l 个数到第 r 个数的和。

输入格式

第一行包含两个整数 n和 m。
第二行包含 n个整数，表示整数数列。
接下来 m行，每行包含两个整数 l 和 r，表示一个询问的区间范围。

输出格式

共 m行，每行输出一个询问的结果。

数据范围

1≤l≤r≤n,1≤n,m≤100000,−1000≤数列中元素的值≤1000

输入样例

5 3
2 1 3 6 4
1 2
1 3
2 4

输出样例

3
6
10

代码

#include<bits/stdc++.h>
using namespace std;
const int N=100010;
int s[N];
int main()
{
    int n,m;
    cin>>n>>m;
    for(int i=1;i<=n;i++)
    {
        int x;
        cin>>x;
        s[i]=s[i-1]+x;
    }
    while(m--)
    {
        int l,r;
        cin>>l>>r;
        cout<<s[r]-s[l-1]<<endl;
    }
    return 0;
}

二维前缀和

问题描述

输入一个 n行 m列的整数矩阵，再输入 q个询问，每个询问包含四个整数 x1,y1,x2,y2，表示一个子矩阵的左上角坐标和右下角坐标。
对于每个询问输出子矩阵中所有数的和。

输入格式

第一行包含三个整数 n，m，q。
接下来 n 行，每行包含 m个整数，表示整数矩阵。
接下来 q 行，每行包含四个整数 x1,y1,x2,y2，表示一组询问。

输出格式

共 q行，每行输出一个询问的结果。

数据范围

1≤n,m≤1000,1≤q≤200000,1≤x1≤x2≤n,1≤y1≤y2≤m,−1000≤矩阵内元素的值≤1000

输入样例

3 4 3
1 7 2 4
3 6 2 8
2 1 2 3
1 1 2 2
2 1 3 4
1 3 3 4

输出样例

17
27
21

问题分析

给出一个二维数组，在给出一个子数组的左上角坐标、右下角坐标，求出子数组中的所有元素的和。
用s[i,j]表示(1,1)~(i,j)的和。

先看看s[i,j]怎么求：

s[1,1] = a[1,1]

s[1,2] = a[1,1] + a[1,2]
       = s[1,1] + a[1,2]

s[1,3] = a[1,1] + a[1,2] + a[1,3] 
       = s[1,2] + a[1,3] 

s[2,1] = a[1,1] + a[2,1] 
       = s[1,1] + a[2,1] 

s[2,2] = a[1,1] + a[1,2] + a[2,1] +  a[2,2] 
       = s[1,2] + s[2,1] - s[1,1] + a[2, 2] 

s[2,3] = a[1,1] + a[1,2] + a[1,3] + a[2,1] + a[2,2] + a[2,3] 
       = s[1,3] + s[2,2] - s[1,2] + a[2, 3] 

可以得到一下公式：
s[i,j] = s[i−1,j]+ s[i,j−1]- s[i−1,j−1]+ a[i][j]
也就是，可以在O(n²)的时间复杂度内求出所有s

如图所示：黄色部分 = 紫色框 - 蓝色框 - 红色框 + 黑色框。
也就是： (x1,y1)~(x2,y2)的和 = s[x2,y2] - s[x1−1,y2] - s[x2,y1−1] + s[x1−1,y1−1]
所以当求出 s后，就能在 O(1)的时间复杂度内，求出子矩阵的和。
所以总时间复杂度是：O(n²)

代码

#include<bits/stdc++.h>
using namespace std;
const int N=100010;
int s[N][N];
int main()
{
    int n,m,q;
    cin>>n>>m>>q;
    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++)
            cin>>s[i][j];
    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++)
            s[i][j]+=s[i-1][j]+s[i][j-1]-s[i-1][j-1];
    while(q--)
    {
        int x1,y1,x2,y2;
        cin>>x1>>y1>>x2>>y2;
        cout<<s[x2][y2]-s[x2][y1-1]-s[x1-1][y2]+s[x1][y1]<<endl;
    }
    return 0;
}

一维差分

问题描述

输入一个长度为 n的整数序列。
接下来输入 m个操作，每个操作包含三个整数 l,r,c，表示将序列中 [l,r] 之间的每个数加上 c。
请你输出进行完所有操作后的序列。

输入格式

第一行包含两个整数 n和 m。
第二行包含 n个整数，表示整数序列。
接下来 m 行，每行包含三个整数 l，r，c，表示一个操作。

输出格式

共一行，包含 n个整数，表示最终序列。

数据范围

1≤n,m≤100000,1≤l≤r≤n,−1000≤c≤1000,−1000≤整数序列中元素的值≤1000

输入样例

6 3
1 2 2 1 2 1
1 3 1
3 5 1
1 6 1

输出样例

3 4 5 3 4 2

问题分析

类似于数学中的求导和积分，差分可以看成前缀和的逆运算。
差分数组：
首先给定一个原数组a：a[1], a[2], a[3], a[n];
然后我们构造一个数组b ： b[1] ,b[2] , b[3], b[i];
使得 a[i] = b[1] + b[2 ]+ b[3] +, + b[i]
也就是说，a数组是b数组的前缀和数组，反过来我们把b数组叫做a数组的差分数组。换句话说，每一个a[i]都是b数组中从头开始的一段区间和。
考虑如何构造差分b数组？
最为直接的方法
如下：

a[0 ]= 0;
b[1] = a[1] - a[0];
b[2] = a[2] - a[1];
b[3] =a [3] - a[2];
........

b[n] = a[n] - a[n-1];

我们只要有b数组，通过前缀和运算，就可以在O(n) 的时间内得到a数组 。
给定区间[l ,r ]，让我们把a数组中的[ l, r]区间中的每一个数都加上c,即 a[l] + c , a[l+1] + c , a[l+2] + c , a[r] + c;
暴力做法是for循环l到r区间，时间复杂度O(n)，如果我们需要对原数组执行m次这样的操作，时间复杂度就会变成O(n*m)。有没有更高效的做法吗? 考虑差分做法。
始终要记得，a数组是b数组的前缀和数组，比如对b数组的b[i]的修改，会影响到a数组中从a[i]及往后的每一个数。
首先让差分b数组中的 b[l] + c ,a数组变成 a[l] + c ,a[l+1] + c, a[n] + c;
然后我们打个补丁，b[r+1] - c, a数组变成 a[r+1] - c,a[r+2] - c,a[n] - c;
为啥还要打个补丁？
看图理解一下这个公式的由来:

b[l] + c，效果使得a数组中 a[l]及以后的数都加上了c(红色部分)，但我们只要求l到r区间加上c, 因此还需要执行 b[r+1] - c,让a数组中a[r+1]及往后的区间再减去c(绿色部分)，这样对于a[r] 以后区间的数相当于没有发生改变。
因此我们得出一维差分结论：给a数组中的[ l, r]区间中的每一个数都加上c,只需对差分数组b做 b[l] + = c, b[r+1] - = c。时间复杂度为O(1), 大大提高了效率。

代码

#include<bits/stdc++.h>
using namespace std;
const int N=100010;
int a[N],b[N];
int n,m;
void insert(int l,int r,int c)
{
    b[l]+=c;
    b[r+1]-=c;
}
int main()
{
    cin>>n>>m;
    for(int i=1;i<=n;i++) cin>>a[i];
    for(int i=1;i<=n;i++) insert(i,i,a[i]);
    while(m--)
    {
        int l,r,c;
        cin>>l>>r>>c;
        insert(l,r,c);
    }
    for(int i=1;i<=n;i++) b[i]+=b[i-1];
    for(int i=1;i<=n;i++) cout<<b[i]<<" ";
    return 0;
}

二维差分

问题描述

输入一个 n行 m列的整数矩阵，再输入 q个操作，每个操作包含五个整数 x1,y1,x2,y2,c，其中 (x1,y1)和 (x2,y2)表示一个子矩阵的左上角坐标和右下角坐标。
每个操作都要将选中的子矩阵中的每个元素的值加上 c。
请你将进行完所有操作后的矩阵输出。

输入格式

第一行包含整数 n,m,q。
接下来 n行，每行包含 m个整数，表示整数矩阵。
接下来 q 行，每行包含 5 个整数 x1,y1,x2,y2,c，表示一个操作。

输出格式

共 n行，每行 m 个整数，表示所有操作进行完毕后的最终矩阵。

数据范围

1≤n,m≤1000,1≤q≤100000,1≤x1≤x2≤n,1≤y1≤y2≤m,−1000≤c≤1000,−1000≤矩阵内元素的值≤1000

输入样例

3 4 3
1 2 2 1
3 2 2 1
1 1 1 1
1 1 2 2 1
1 3 2 3 2
3 1 3 4 1

输出样例

2 3 4 1
4 3 4 1
2 2 2 2

思路分析

  如果扩展到二维，我们需要让二维数组被选中的子矩阵中的每个元素的值加上c,是否也可以达到O(1)的时间复杂度。答案是可以的，考虑二维差分。
  a[ ][ ]数组是b[ ][ ]数组的前缀和数组，那么b[ ][ ]是a[ ][ ]的差分数组
  原数组： a[i][j]
  我们去构造差分数组： b[i][j]使得a数组中a[i][j]是b数组左上角(1,1)到右下角(i,j)所包围矩形元素的和。
  如何构造b数组呢？
  我们去逆向思考。
  同一维差分，我们构造二维差分数组目的是为了 让原二维数组a中所选中子矩阵中的每一个元素加上c的操作，可以由O(n*n)的时间复杂度优化成O(1)
  已知原数组a中被选中的子矩阵为 以(x1,y1)为左上角，以(x2,y2)为右下角所围成的矩形区域;
  始终要记得，a数组是b数组的前缀和数组，比如对b数组的b[i][j]的修改，会影响到a数组中从a[i][j]及往后的每一个数。
  假定我们已经构造好了b数组，类比一维差分，我们执行以下操作来使被选中的子矩阵中的每个元素的值加上c

b[x1][y1] += c;

b[x1,][y2+1] -= c;

b[x2+1][y1] -= c;

b[x2+1][y2+1] += c;

我们画个图去理解一下这个过程：

b[x1][ y1 ] +=c ; 对应图1 ,让整个a数组中蓝色矩形面积的元素都加上了c。
b[x1][y2+1]-=c ; 对应图2 ,让整个a数组中绿色矩形面积的元素再减去c，使其内元素不发生改变。
b[x2+1][y1]- =c ; 对应图3 ,让整个a数组中紫色矩形面积的元素再减去c，使其内元素不发生改变。
b[x2+1][y2+1]+=c; 对应图4,让整个a数组中红色矩形面积的元素再加上c，红色内的相当于被减了两次，再加上一次c，才能使其恢复。

代码

#include<bits/stdc++.h>
using namespace std;
const int N=1010;
int a[N][N],b[N][N]; // 定义两个二维数组a和b，用于存储输入的矩阵和处理后的矩阵
int n,m,q; // 定义三个整数变量n、m和q，分别表示矩阵的行数、列数和操作次数

// 定义一个插入函数，用于在b矩阵中插入一个矩形区域，该区域的值为c
void insert(int x1,int y1,int x2,int y2,int c)
{
    b[x1][y1]+=c;
    b[x2+1][y1]-=c;
    b[x1][y2+1]-=c;
    b[x2+1][y2+1]+=c;
}

int main()
{
    cin>>n>>m>>q; // 输入矩阵的行数、列数和操作次数
    for(int i=1;i<=n;i++) // 遍历矩阵的每一行
        for(int j=1;j<=m;j++) // 遍历矩阵的每一列
            cin>>a[i][j]; // 输入矩阵的元素值
    for(int i=1;i<=n;i++) // 遍历矩阵的每一行
        for(int j=1;j<=m;j++) // 遍历矩阵的每一列
            insert(i,j,i,j,a[i][j]); // 将矩阵的元素值插入到b矩阵中
    while(q--) // 进行q次操作
    {
        int x1,y1,x2,y2,c; // 定义五个整数变量，分别表示操作的起始坐标和矩形区域的值
        cin>>x1>>y1>>x2>>y2>>c; // 输入操作的起始坐标和矩形区域的值
        insert(x1,y1,x2,y2,c); // 将矩形区域插入到b矩阵中
    }
    for(int i=1;i<=n;i++) // 遍历矩阵的每一行
        for(int j=1;j<=m;j++) // 遍历矩阵的每一列
            b[i][j]+=b[i-1][j]+b[i][j-1]-b[i-1][j-1]; // 更新b矩阵的值
    for(int i=1;i<=n;i++) // 遍历矩阵的每一行
    {
        for(int j=1;j<=m;j++) cout<<b[i][j]<<" "; // 输出b矩阵的元素值
        cout<<endl; // 换行
    }
    return 0;
}