一,差分定义
差分,就是前缀和的逆运算。
二,具体过程
1.一维差分
例题
构造差分数组
首先给定一个原数组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 数组 。
例如一个序列 5 4 6 2 7
每个数减去前面一个数得到一个新的序列，第一个数默认减0，得到新序列5 -1 2 -4 5
这个新序列就是差分数组
将差分数组求前缀和 ，就可以得到原序列 5 4 6 2 7(毕竟差分是前缀和的逆运算嘛)
那么知道了差分数组该如何区间修改呢?
修改操作
暴力做法是直接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[r + 1] - 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), 大大提高了效率。
假设要在区间[2,4]内每个数加2。
接下来对差分数组5 -1 2 -4 5进行如下操作。
第一行为数组下标。在下标为2处+2，在下标为5处-2。
得到新的差分数组 5 1 2 -4 3。
对新的差分数组求前缀和，得到数组5 6 8 4 7。发现实现了区间[2,4]每个数+2的操作。
代码
#include <bits/stdc++.h>
#define int long long
using namespace std;
int n,m,a[1000001],s,c[10000001];
void bil()//构造差分数组
{
for(int i = 1;i <= n;i++) c[i] = a[i] - a[i - 1];
}
void gexi(int x,int y,int z)//修改操作
{
c[x] += z;
c[y + 1] -= z;
}
signed main()
{
cin>>n>>m;
for(int i = 1;i <= n;i++) cin>>a[i];
bil();
while(m--)
{
int x,y,z;
cin>>x>>y>>z;
gexi(x,y,z);
}
s = c[1];
cout<<s<<' ';
for(int i = 2;i <= n;i++) s += c[i],cout<<s<<' ';
return 0;
}2.二维差分
引入
建议先看看二维前缀和
例题
Acwing798. 差分矩阵
构造差分数组
扩展到了二维，我们需要让二维数组被选中的子矩阵中的每个元素的值加上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数组执行以上操作，等价于：
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 gexi(int x1,int y1,int x2,int y2,int x)
{
c[x1][y1] += x;
c[x1][y2 + 1] -= x;
c[x2 + 1][y1] -= x;
c[x2 + 1][y2 + 1] += x;
}我们可以先假想a数组为空，那么b数组一开始也为空，但是实际上a数组并不为空，因此我们每次让以(i,j)为左上角到以(i,j)为右下角面积内元素(其实就是一个小方格的面积)去插入 c = a[i][j] ，等价于原数组a中(i,j) 到(i,j)范围内 加上了 a[i][j] ,因此执行 n*m次插入操作，就成功构建了差分b数组.
代码
#include <bits/stdc++.h>
#define ll long long
using namespace std;
int n,m,q,a[1002][1002],c[1002][1002];
void gexi(int x1,int y1,int x2,int y2,int x)
{
c[x1][y1] += x;
c[x1][y2 + 1] -= x;
c[x2 + 1][y1] -= x;
c[x2 + 1][y2 + 1] += x;
}
signed main()
{
cin>>n>>m>>q;
for(int i = 1;i <= n;i++)
for(int j = 1;j <= m;j++)
{
cin>>a[i][j];
gexi(i,j,i,j,a[i][j]);
}
while(q--)
{
int x1,y1,x2,y2,x;
cin>>x1>>y1>>x2>>y2>>x;
gexi(x1,y1,x2,y2,x);
}
for(int i = 1;i <= n;i++)
for(int j = 1;j <= m;j++)
c[i][j] += c[i - 1][j] + c[i][j - 1] - c[i - 1][j - 1];
for(int i = 1;i <= n;i++)
{
for(int j = 1;j <= m;j++)
cout<<c[i][j]<<' ';
cout<<'\n';
}
return 0;
}
