题解：学而思编程 子矩阵的和

【题目来源】

学而思编程：子矩阵的和

【题目描述】

有一个 \(n\times m\) 的矩阵，第 \(i\) 行第 \(j\) 列格子的值为 \(a_{i,j}\)，现在小猴有 \(q\) 个问题 ------ 给出两个正方形区域（第 \(k\) 个正方形左上角格子在第 \(x_k\) 行第 \(y_k\) 列，边长为 \(len_k\)），请问被区域覆盖的子矩阵中的所有的元素之和是多少？

【输入】

第一行两个正整数 \(n\)，\(m\)；

接下来 \(n\) 行，每行 \(m\) 格整数 \(a_{i,1},\dots,a_{i,m}\)；

接下来一行一个正整数 \(q\)；

接下来 \(q\) 行每行六个整数 \(x_1,y_1,len_1,x_2,y_2,len_2\)。

【输出】

共 \(q\) 行，每行一个整数表示结果。

【输入样例】

2 2
1 2
3 4
3
1 1 1 2 2 1
1 2 1 2 1 1
2 1 1 2 2 1

【输出样例】

5
5
7

【核心思想】

1. 问题分析：给定 \(n \times m\) 的矩阵和 \(q\) 个查询，每个查询给出两个正方形区域（由左上角坐标和边长定义），需要计算这两个区域覆盖的所有元素之和。若两个正方形相交，交集部分会被重复计算，需要减去一次交集。关键观察是：两个正方形的并集面积 = 面积1 + 面积2 - 交集面积。

2. 算法选择：

   • 行前缀和：对矩阵的每一行预处理前缀和，实现 \(O(1)\) 的单行区间查询
   • 容斥原理：利用集合的并集公式计算两个区域的并集和，避免重复计算交集部分

3. 关键步骤：

   • 预处理行前缀和：对每行 \(i\)，\(a[i][j] \leftarrow a[i][j] + a[i][j-1]\)，使得 \(a[i][j]\) 表示第 \(i\) 行前 \(j\) 个元素之和
   • 计算子矩阵和 area(x1, y1, x2, y2)：
     • 遍历行 \(i\) 从 \(x_1\) 到 \(x_2\)
     • 每行贡献为 \(a[i][y_2] - a[i][y_1 - 1]\)
     • 累加所有行贡献
   • 处理每个查询：
     • 计算两个正方形的右下角坐标：\((x_1 + len_1 - 1, y_1 + len_1 - 1)\) 和 \((x_2 + len_2 - 1, y_2 + len_2 - 1)\)
     • 并集和 = 正方形1的和 + 正方形2的和
     • 若两正方形相交（非分离），计算交集区域并减去其和
   • 交集判定与计算：
     • 不相交条件：\(x_{1,\text{右}} < x_{2,\text{左}}\) 或 \(y_{1,\text{右}} < y_{2,\text{左}}\) 或 \(x_{1,\text{左}} > x_{2,\text{右}}\) 或 \(y_{1,\text{左}} > y_{2,\text{右}}\)
     • 若相交：对 \(x\) 坐标和 \(y\) 坐标分别排序，交集为 \([x[2], x[3]] \times [y[2], y[3]]\)

4. 时间/空间复杂度：

   • 时间复杂度：\(O(n \cdot m + q \cdot (n + \log n))\)，预处理 \(O(n \cdot m)\)，每次查询计算两个正方形 \(O(n)\)（行数），交集判定排序 \(O(\log n)\)，减去交集 \(O(n)\)
   • 空间复杂度：\(O(n \cdot m)\)，存储矩阵和行前缀和

5. 行前缀和与容斥原理的核心思想：

   • 一维前缀和降维：通过每行的前缀和，将二维子矩阵和查询降为一维行区间和的累加，避免了完整的二维前缀和预处理，在空间受限或行数较少时更灵活
   • 容斥去重：两个区域的并集和 = 和1 + 和2 - 交集和，这是处理重叠区域统计的经典方法，确保每个元素恰好被计算一次
   • 交集坐标提取：将两个矩形的所有 \(x\) 坐标排序后，中间两个值即为交集的左右边界；\(y\) 坐标同理。这一技巧避免了复杂的条件分支判断
   • 分离条件判定：通过判断两个矩形在 \(x\) 轴或 \(y\) 轴上的投影是否分离，快速排除不相交的情况
   • 适用于多区域并集统计、重叠区域处理、矩阵子区域查询等场景

【解题思路】

【算法标签】

前缀和

【代码详解】

#include <bits/stdc++.h>
using namespace std;
int x[5], y[5];  // 存储两个矩形的坐标
long long a[510][510];  // 矩阵，存储每行的前缀和

// 计算子矩阵的和
long long area(int x1, int y1, int x2, int y2)
{
    long long sum = 0;
    for (int i = x1; i <= x2; i++)  // 遍历每一行
    {
        // 使用行前缀和计算该行的区间和
        sum += a[i][y2] - a[i][y1 - 1];
    }
    return sum;
}
int main()
{
    int n, m;
    cin >> n >> m;  // 输入矩阵大小

    // 输入矩阵并计算每行的前缀和
    for (int i = 1; i <= n; i++)  // 行
    {
        for (int j = 1; j <= m; j++)  // 列
        {
            cin >> a[i][j];  // 输入元素
            a[i][j] += a[i][j - 1];  // 行前缀和
        }
    }

    int q;
    cin >> q;  // 查询次数
    while (q--)  // 处理每个查询
    {
        int x1, y1, x2, y2, len1, len2;
        cin >> x1 >> y1 >> len1 >> x2 >> y2 >> len2;

        // 计算第一个矩形的坐标
        x[1] = x1;
        y[1] = y1;
        x[2] = x[1] + len1 - 1;
        y[2] = y[1] + len1 - 1;

        // 计算第二个矩形的坐标
        x[3] = x2;
        y[3] = y2;
        x[4] = x[3] + len2 - 1;
        y[4] = y[3] + len2 - 1;

        long long ans = 0;
        ans += area(x[1], y[1], x[2], y[2]);  // 第一个矩形的和
        ans += area(x[3], y[3], x[4], y[4]);  // 第二个矩形的和

        // 判断两个矩形是否相交
        if (!(x[2] < x[3] || y[2] < y[3] || x[1] > x[4] || y[1] > y[4]))
        {
            // 排序坐标，计算交集
            sort(x + 1, x + 4 + 1);
            sort(y + 1, y + 4 + 1);
            // 减去交集部分（避免重复计算）
            ans -= area(x[2], y[2], x[3], y[3]);
        }
        cout << ans << endl;
    }
    return 0;
}

【运行结果】

2 2
1 2
3 4
3
1 1 1 2 2 1
5
1 2 1 2 1 1
5
2 1 1 2 2 1
7