一维,二维差分の详解（简单易懂）

一,差分定义

差分,就是前缀和的逆运算。

二,具体过程

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;
}

三.结语

如果这篇文章对您有帮助的话，请记得点赞收藏加关注吖(●'◡'●)