Acwing---798.差分矩阵

差分矩阵

• 1.题目
• 2.基本思想
• 3.代码实现

  1.题目

  输入一个 n n n 行 m m m列的整数矩阵，再输入 q q q 个操作，每个操作包含五个整数 x 1 , y 1 , x 2 , y 2 , c x1,y1,x2,y2,c x1,y1,x2,y2,c，其中 ( x 1 , y 1 ) (x1,y1) (x1,y1) 和 ( x 2 , y 2 ) (x2,y2) (x2,y2)表示一个子矩阵的左上角坐

  标和右下角坐标。

  每个操作都要将选中的子矩阵中的每个元素的值加上 c c c。

  请你将进行完所有操作后的矩阵输出。

  输入格式

  第一行包含两个整数 n n n 和 m m m。

  第二行包含 n n n 个整数，表示整数序列。

  接下来 m m m 行，每行包含三个整数 l ， r ， c l，r，c l，r，c，表示一个操作。

  输出格式

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

  数据范围

  1 ≤ n , m ≤ 1000 , 1≤n,m≤1000, 1≤n,m≤1000,

  1 ≤ q ≤ 100000 , 1≤q≤100000, 1≤q≤100000,

  1 ≤ x 1 ≤ x 2 ≤ n , 1≤x1≤x2≤n, 1≤x1≤x2≤n,

  1 ≤ y 1 ≤ y 2 ≤ m , 1≤y1≤y2≤m, 1≤y1≤y2≤m,

  − 1000 ≤ c ≤ 1000 , −1000≤c≤1000, −1000≤c≤1000,

  − 1000 ≤ 矩阵内元素的值 ≤ 1000 −1000≤矩阵内元素的值≤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

  2.基本思想

  前缀和的逆运算

  如果扩展到二维，我们需要让二维数组被选中的子矩阵中的每个元素的值加上 c c c,是否也可以达到 O ( 1 ) O(1) O(1)的时间复杂度。答案是可以的，考虑二维差分。

  a [ ] [ ] a[][] a[][]数组是 b [ ] [ ] b[][] b[][]数组的前缀和数组，那么 b [ ] [ ] b[][] b[][]是 a [ ] [ ] a[][] a[][]的差分数组

  原数组： a [ i ] [ j ] a[i][j] a[i][j]

  我们去构造差分数组： b [ i ] [ j ] b[i][j] b[i][j]

  使得 a a a数组中 a [ i ] [ j ] a[i][j] a[i][j]是 b b b数组左上角 ( 1 , 1 ) (1,1) (1,1)到右下角 ( i , j ) (i,j) (i,j)所包围矩形元素的和。

  如何构造 b b b数组呢？

  我们去逆向思考。

  同一维差分，我们构造二维差分数组目的是为了 让原二维数组 a a a中所选中子矩阵中的每一个元素加上 c c c的操作，可以由 O ( n ∗ n ) O(n*n) O(n∗n)的时间复杂度优化成 O ( 1 ) O(1) O(1)

  已知原数组 a a a中被选中的子矩阵为 以 ( x 1 , y 1 ) (x1,y1) (x1,y1)为左上角，以 ( x 2 , y 2 ) (x2,y2) (x2,y2)为右下角所围成的矩形区域;

  始终要记得， a a a数组是 b b b数组的前缀和数组，比如对 b b b数组的 b [ i ] [ j ] b[i][j] b[i][j]的修改，会影响到 a a a数组中从 a [ i ] [ j ] a[i][j] a[i][j]及往后的每一个数。

  假定我们已经构造好了 b b b数组，类比一维差分，我们执行以下操作

  来使被选中的子矩阵中的每个元素的值加上 c c 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]);    //构建差分数组
        }
    }
  

  总结

  

  3.代码实现

  import java.util.Scanner;
  public class Main {
      static int N = 1010;
      static int[][] a = new int[N][N], b = new int[N][N];
      public static void main(String[] args) {
          Scanner sc = new Scanner(System.in);
          int n = sc.nextInt(), m = sc.nextInt(), q = sc.nextInt();
          for (int i = 1; i <= n; i++)
              for (int j = 1; j <= m; j++)
                  a[i][j] = sc.nextInt();
          for (int i = 1; i <= n; i++)
              for (int j = 1; j <= m; j++)
                  insert(i, j, i, j, a[i][j]);
          while (q-- > 0) {
              int x1 = sc.nextInt(), y1 = sc.nextInt(), x2 = sc.nextInt(), y2 = sc.nextInt(), c = sc.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();
          }
      }
      private static 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;
      }
  }