二维差分矩阵

差分矩阵

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

所用方法和基本原理

1. 二维差分矩阵原理：
   • 与一维差分类似，二维差分是二维前缀和的逆运算。对于一个二维数组 a，其对应的二维差分数组 b 满足： [b_{i,j}=a_{i,j}-a_{i - 1,j}-a_{i,j - 1}+a_{i - 1,j - 1}]
   • 对二维差分数组 b 进行操作 insert(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 中以 (x1, y1) 为左上角、(x2, y2) 为右下角的子矩阵内的每个元素都加上 c。
   • 当通过前缀和还原原数组时，这样的操作能保证子矩阵内元素增加 c，而子矩阵外元素不受影响。例如，在计算原矩阵某位置 (i, j) 的值时，由于差分数组的修改，子矩阵内的元素会累加到正确的值。
2. 具体实现：
   • insert 方法实现了对二维差分数组的操作，按照上述规则修改差分数组对应位置的值。
   • prefixSum 方法通过对二维差分数组求前缀和来还原出经过所有操作后的原矩阵。利用二维前缀和的计算方式，通过双重循环遍历差分数组 b，根据公式 a[i][j] = a[i - 1][j] + a[i][j - 1] - a[i - 1][j - 1] + b[i][j] 来计算原矩阵每个位置的值。

代码及注释

import java.util.Scanner;

public class DifferenceMatrix {
    // 定义二维差分数组b，这里预留了一定的额外空间
    public static int[][] b = new int[1000 + 10][1000 + 10];

    // 插入操作，对二维差分数组进行修改
    public 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;
    }

    // 通过二维差分数组求前缀和还原出最终的矩阵
    public static int[][] prefixSum(int[][] b) {
        int[][] a = new int[b.length][b[0].length];
        for (int i = 1; i < b.length; i++) {
            for (int j = 1; j < b[0].length; j++) {
                // 根据二维前缀和公式计算原矩阵的值
                a[i][j] = a[i - 1][j] + a[i][j - 1] - a[i - 1][j - 1] + b[i][j];
            }
        }
        return a;
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int m = sc.nextInt();
        int q = sc.nextInt();
        // 初始化二维差分数组，将原矩阵的每个元素看作是1x1的子矩阵插入
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++) {
                int tmp = sc.nextInt();
                insert(i, j, i, j, tmp);
            }
        }
        // 进行q次操作
        for (int i = 0; i < q; i++) {
            int x1 = sc.nextInt();
            int y1 = sc.nextInt();
            int x2 = sc.nextInt();
            int y2 = sc.nextInt();
            int c = sc.nextInt();
            insert(x1, y1, x2, y2, c);
        }
        // 通过二维差分数组还原出最终的矩阵
        int[][] a = prefixSum(b);

        // 输出最终的矩阵
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++) {
                System.out.print(a[i][j] + " ");
            }
            System.out.println();
        }
    }
}

举例说明

假设输入一个 3x3 的矩阵 [[1, 2, 3], [4, 5, 6], [7, 8, 9]]，即 n = 3，m = 3，有 q = 1 个操作，操作参数为 x1 = 1，y1 = 1，x2 = 2，y2 = 2，c = 2。

1. 初始化二维差分数组：

   • 对原矩阵每个元素进行 insert(i, j, i, j, tmp) 操作。
   • 例如，对于 (1, 1) 位置，执行 insert(1, 1, 1, 1, 1)，差分数组 b 相应位置改变。最终差分数组 b 反映了原矩阵每个元素的初始化状态。

2. 进行操作：

   • 执行操作 insert(1, 1, 2, 2, 2)，差分数组 b 变为：

     0	0	0	0
     0	2	0	-2
     0	0	0	0
     0	-2	0	2

3. 还原矩阵：

   • 通过 prefixSum 方法还原矩阵。

   • 以 (2, 2) 位置为例，a[2][2] = a[1][2] + a[2][1] - a[1][1] + b[2][2]。逐步计算整个矩阵的值，最终得到操作后的矩阵：

     1	4	3
     6	9	6
     7	8	9

方法的优劣

1. 时间复杂度：
   • 初始化阶段：初始化二维差分数组，通过双重循环遍历原矩阵每个元素，时间复杂度为 (O(n \times m))。
   • 操作阶段：进行 q 次操作，每次操作对差分数组的修改时间复杂度为 (O(1))，所以这部分时间复杂度为 (O(q))。
   • 还原阶段：通过双重循环对二维差分数组求前缀和还原矩阵，时间复杂度为 (O(n \times m))。
   • 总体时间复杂度为 (O(n \times m + q))。相比于每次操作都遍历子矩阵内所有元素的暴力解法（时间复杂度为 (O(q \times n \times m))），在处理多个操作时效率有显著提升。
2. 空间复杂度：
   • 需要额外的空间来存储二维差分数组 b，空间复杂度为 (O(n \times m))，因为二维差分数组的大小与原矩阵相同（这里预留了额外空间）。

优点： - 对于频繁的子矩阵区间修改操作，时间复杂度较低，能高效处理大量操作。 - 实现思路基于二维前缀和与差分的关系，逻辑相对清晰，易于理解和实现。

缺点： - 空间复杂度较高，需要与原矩阵相同大小的额外空间来存储差分数组，对于大规模矩阵可能会占用较多内存。 - 仅适用于子矩阵区间修改、单点查询的场景，如果需要进行子矩阵区间查询等其他操作，可能需要结合其他数据结构。