前缀和
什么是前缀和？
- 数列的和时，Sn = a1+a2+a3+…an; Sn就是数列的前 n 项和。
- 前缀和就是新建一个数组，新建数组中保存原数组前 n 项的和。
前缀和有什么用？
-
快速求某个区间中所有元素的加和。
-
例 S4 = a1 + a2 + a3 + a4; S1 = a1。所以可以通过 S4-S1 得到 a2+a3+a4 的值。
具体做法：
首先做一个预处理，定义一个sum[]数组，sum[i]代表a数组中前i个数的和。
求前缀和运算：
const int N = 1e5+10;
int sum[N], a[N]; //sum[i] = a[1] + a[2] + a[3] ..... a[i];
for(int i = 1; i <= n;i++)
{
sum[i] = sum[i - 1] + a[i];
}
然后查询操作：
scanf("%d%d", &l, &r);
printf("%d\n", sum[r] - sum[l - 1]);
对于每次查询，只需执行sum[r] - sum[l - 1] ，时间复杂度为O(1)
原理
sum[r] = a[1] + a[2] + a[3] + a[l-1] + a[l] + a[l+1] ...... a[r];
sum[l - 1] = a[1] + a[2] + a[3] + a[l - 1];
sum[r] - sum[l - 1] = a[l] + a[l + 1]+......+ a[r];
图解
这样，对于每个询问，只需要执行 sum[r]-sum[l-1]。输出原序列中从第l个数到第r个数的和的时间复杂度变成了O(1)。
我们把它叫做一维前缀和。
总结：
代码
#include<iostream>
#include<cstdio>
using namespace std;
const int N=1e5+10;
int a[N],sum[N];
int main()
{
int n,m,x;
cin>>n>>m;
for(int i=1;i<=n;i++)
{
cin>>x;
sum[i]=x+sum[i-1];
}
while(m--)
{
int l,r;
cin>>l>>r;
cout<<sum[r]-sum[l-1]<<endl;
}
return 0;
}
Java代码
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner scan = new Scanner(System.in);
int n = scan.nextInt();
int m = scan.nextInt();
int[] a = new int[n+1];
int[] s = new int[n+1];
for(int i = 1 ; i <= n ; i ++ ){
a[i] = scan.nextInt();
}
for(int i = 1 ; i <= n ; i ++){
s[i] = s[i-1] + a[i];
}
while(m-- > 0){
int l = scan.nextInt();
int r = scan.nextInt();
System.out.println(s[r] - s[l-1]);
}
}
}
二维前缀和
推导
如图：
紫色面积是指(1,1)左上角到(i,j-1)右下角的矩形面积, 绿色面积是指(1,1)左上角到(i-1, j )右下角的矩形面积。每一个颜色的矩形面积都代表了它所包围元素的和。
**从图中我们很容易看出，**整个外围蓝色矩形面积s[i][j] = 绿色面积s[i-1][j] + 紫色面积s[i][j-1] - 重复加的红色的面积s[i-1][j-1]+小方块的面积a[i][j];
因此得出二维前缀和预处理公式
s[i] [j] = s[i-1][j] + s[i][j-1 ] + a[i] [j] - s[i-1][ j-1],
接下来回归问题去求以(x1,y1)为左上角和以(x2,y2)为右下角的矩阵的元素的和。
如图：
紫色面积是指 ( 1,1 )左上角到(x1-1,y2)右下角的矩形面积 ，黄色面积是指(1,1)左上角到(x2,y1-1)右下角的矩形面积；
不难推出：
绿色矩形的面积 = 整个外围面积s[x2, y2] - 黄色面积s[x2, y1 - 1] - 紫色面积s[x1 - 1, y2] + 重复减去的红色面积 s[x1 - 1, y1 - 1]
因此二维前缀和的结论为：
以(x1, y1)为左上角，(x2, y2)为右下角的子矩阵的和为：
s[x2, y2] - s[x1 - 1, y2] - s[x2, y1 - 1] + s[x1 - 1, y1 - 1],
总结：
代码：
#include <iostream>
using namespace std;
const int N = 1010;
int n, m, q;
int s[N][N];
int main()
{
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= n; i ++ )
for (int j = 1; j <= m; j ++ )
scanf("%d", &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;
scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
printf("%d\n", s[x2][y2] - s[x1 - 1][y2] - s[x2][y1 - 1] + s[x1 - 1][y1 - 1]);
}
return 0;
}
Java代码
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner scan = new Scanner(System.in);
int n = scan.nextInt();
int m = scan.nextInt();
int q = scan.nextInt();
int[][] a = new int[n+1][m+1];
int[][] s = new int[n+1][m+1];
for(int i = 1 ; i <= n ; i ++ ){
for(int j = 1 ;j <= m ; j ++ ){
a[i][j] = scan.nextInt();
}
}
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] + a[i][j];
}
}
while(q-->0){
int x1 = scan.nextInt();
int y1 = scan.nextInt();
int x2 = scan.nextInt();
int y2 = scan.nextInt();
System.out.println(s[x2][y2] - s[x1-1][y2] - s[x2][y1-1] + s[x1-1][y1-1]);
}
}
}
差分
类似于数学中的求导和积分，差分可以看成前缀和的逆运算。
从前缀和一步步推导出差分
看一下前缀和数组：
若原数组 a = [3, 1, 2, 5, 7]
则前缀和数组 b = [3,4,6,11,18]
对 a 数组进行操作对应前缀和数组的什么操作？
对 a 数组的某个元素增加c，对应前缀和数组的操作是：
- 对 a[2] 增加 3， 则 b 数组变为：[3, 4, 6 + 3, 11 + 3, 18 + 3] = [3, 1, 5, 8, 10]
- 原数组 a 的某个元素增加一个数，则对应前缀和数组 s 变化是：该元素及他之后的元素都增加 c
也就是: 如果原数组 a[x] 变化，则前缀和数组 s ： x 和 x 之后的元素全都变化
根据上面规律，对原数组 a ，如果 a[l] 增加 c， a[r] 减少 c（增加 -c），对应前缀数组 s 的操作是：
a[l] 增加 c：前缀数组 s的变化是：l 和 l 之后的元素增加 c，如下图：
a[r] 减少 c：前缀数组 s的变化是：r 和 r之后的元素减少 c，如下图：
前缀数组 s 总的变化：s 的[l, r - ]区间的数增加 c，如下图：
总结下就是：
原数组的单点操作，对应前缀和数组的区间操作
前缀和数组的区间操作，对应原数组的单点操作
来看题目
输入一个长度为 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 数组。
- 如果用暴力的方法做，改变区间元素的时间复杂度：O(n)，如果有 m 次操作，总时间负责度是 O(n * m)
**如果构造出一个数组 b，b 的前缀和是数组 a，那么对 a 的区间操作，对应b 的单点操作。**根据前缀和的性质，可以通过数组 b 求出数组 a，也可以通过数组 a 求出数组 b.
我们在区间操作之前构造出数组 b，那么 a 的区间操作，对应 b 的两点操作。
接下来的若干区间操作，不应用的数组 a 上，而是将该区间操作对应的两点操作应用到b上。等所有操作都完成后，再从 b 还原出数组 a 。
这样，就将区间操作转换成了两点操作。额外付出的代价是：构造数 b，从数组 b 换原出数组 a。m 次区间操作对应的时间复杂度是O(n)。
将 m 次对 a 的区间操作，转换成 m 次对 b 的两点操作，再由 b 换原出 a即可
这里的数组 b 叫做 a 的差分数组。
看一下如何构造出差分数 b：
首先假设a,b都为空数组，也就是全部为0的情况，
因为a[i][j] = b[1][1]+…b[i][j],因为都是0，所有情况满足！
这总情况下，b 数组是 a 数组的差分数组！
实际上，a数组不为空，我们可以把a数组中的值看作（0+a[i][j]）。
相当于在数组 a 中, 在区间[i, i] 上加了 a[i].
对应前缀和数组 b的操作是：b[i] += a[i], b[i + 1] -= a[i]
所以：
b[i] = a[i] - a[i - 1],
代码
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 100010;
int a[N];
int b[N];
int n, m;
int main()
{
cin >> n >> m;
// 读入数组 a
for (int i = 1; i <= n; i ++ ) cin >> a[i];
// 构造差分数组 b
for (int i = 1; i <= n; i ++ ) b[i] = a[i] - a[i - 1];
// 执行m次操作
while(m--)
{
int l, r, k;
// 区间操作转换为两点操作
cin >> l >> r >> k;
b[l] += k;
b[r + 1] -= k;
}
// 通过前缀和，还原数组a
for (int i = 1; i <= n; i ++ )
{
a[i] = a[i - 1] + b[i];
// 输出结果
cout <<a[i]<<" ";
}
return 0;
}
Java代码
import java.util.Scanner;
public class Main{
int[] b = new int[100010];
public void insert(int l ,int r ,int c){
b[l] += c;
b[r+1] -= c;
}
public static void main(String[] args){
new Main().test();
}
public void test(){
Scanner scan = new Scanner(System.in);
int n = scan.nextInt();
int m = scan.nextInt();
int[] a = new int[n+1];
for(int i = 1 ; i <= n ; i ++ ){
a[i] = scan.nextInt();
}
for(int i = 1;i <= n ; i ++ ){
insert(i,i,a[i]);
}
while(m-->0){
int l = scan.nextInt();
int r = scan.nextInt();
int c = scan.nextInt();
insert(l,r,c);
}
for(int i = 1;i <= n ; i ++ ){
a[i] = a[i-1] + b[i];
System.out.print(a[i] + " ");
}
}
}
二维差分
如果扩展到二维，我们需要让二维数组被选中的子矩阵中的每个元素的值加上c,是否也可以达到O(1)的时间复杂度。答案是可以的，考虑二维差分。
题目
输入一个 n 行 m 列的整数矩阵，再输入 q 个操作，每个操作包含五个整数 x1,y1,x2,y2,c ，其中 (x1,y1) 和 (x2,y2) 表示一个子矩阵的左上角坐标和右下角坐标。
每个操作都要将选中的子矩阵中的每个元素的值加上 c 。
请你将进行完所有操作后的矩阵输出。
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数组执行以上操作，等价于：
for(int i=x1;i<=x2;i++)
for(int j=y1;j<=y2;j++)
a[i][j]+=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，才能使其恢复。
我们将上述操作封装成一个插入函数:
void insert(int x1,int y1,int x2,int y2,int c)
{ //对b数组执行插入操作，等价于对a数组中的(x1,y1)到(x2,y2)之间的元素都加上了c
b[x1][y1]+=c;
b[x2+1][y1]-=c;
b[x1][y2+1]-=c;
b[x2+1][y2+1]+=c;
}
我们可以先假想a数组为空，那么b数组一开始也为空，但是实际上a数组并不为空，因此我们每次让b数组以(i,j)为左上角到以(i,j)为右下角面积内元素(其实就是一个小方格的面积)去插入 c=a[i][j]，等价于原数组a中(i,j) 到(i,j)范围内 加上了 a[i][j] ,因此执行n*m次插入操作，就成功构建了差分b数组.
这叫做曲线救国。
代码如下：
for(int i=1;i<=n;i++)
{
for(int j=1;j<=m;j++)
{
insert(i,j,i,j,a[i][j]); //构建差分数组
}
}
总结：
代码
#include<iostream>
#include<cstdio>
using namespace std;
const int N = 1e3 + 10;
int a[N][N], b[N][N];
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()
{
int n, m, q;
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]); //构建差分数组
}
}
while (q--)
{
int x1, y1, x2, y2, c;
cin >> x1 >> y1 >> x2 >> y2 >> c;
insert(x1, y1, x2, y2, c);
}
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]; //二维前缀和
}
}
for (int i = 1; i <= n; i++)
{
for (int j = 1; j <= m; j++)
{
printf("%d ", b[i][j]);
}
printf("\n");
}
return 0;
}
Java代码
import java.util.*;
public class Main{
static int N = 1010;
static int n, m, q;
static int[][] b = new int[N][N];
static int[][] a = new int[N][N];
public static void insert(int x1, int y1, int x2, int y2, int c){
b[x1][y1] += c;
b[x1][y2 + 1] -= c;
b[x2 + 1][y1] -= c;
b[x2 + 1][y2 + 1] += c;
}
public static void main(String[] args){
Scanner scan = new Scanner(System.in);
n = scan.nextInt();
m = scan.nextInt();
q = scan.nextInt();
for (int i = 1; i <= n; i ++)
for (int j = 1; j <= m; j ++){
a[i][j] = scan.nextInt();
insert(i, j, i, j, a[i][j]);
}
while (q -- > 0){
int x1 = scan.nextInt();
int y1 = scan.nextInt();
int x2 = scan.nextInt();
int y2 = scan.nextInt();
int c = scan.nextInt();
insert(x1, y1, x2, y2, c);
}
for (int i = 1; i <= n; i ++)
for (int j = 1; j <= m; j ++)
b[i][j] += b[i][j - 1] + b[i - 1][j] - b[i - 1][j - 1];
for (int i = 1; i <= n; i ++){
for (int j = 1; j <= m; j ++)
System.out.print(b[i][j] + " ");
System.out.println();
}
}
}
