题解：洛谷 P3397 地毯

【题目来源】

洛谷：P3397 地毯 - 洛谷

【题目描述】

在 \(n\times n\) 的格子上有 \(m\) 个地毯。

给出这些地毯的信息，问每个点被多少个地毯覆盖。

【输入】

第一行，两个正整数 \(n,m\)。意义如题所述。

接下来 \(m\) 行，每行两个坐标 \((x_1,y_1)\) 和 \((x_2,y_2)\)，代表一块地毯，左上角是 \((x_1,y_1)\)，右下角是 \((x_2,y_2)\)。

【输出】

输出 \(n\) 行，每行 \(n\) 个正整数。

第 \(i\) 行第 \(j\) 列的正整数表示 \((i,j)\) 这个格子被多少个地毯覆盖。

【输入样例】

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

【输出样例】

0 1 1 1 0
0 1 1 0 0
0 1 2 1 1
0 0 1 1 1
0 0 1 1 1

【核心思想】

1. 问题分析：给定一个 \(n \times n\) 的网格，有 \(m\) 个矩形区域需要将覆盖次数加 \(1\)（每个地毯覆盖一个矩形），最终需要输出每个格子被多少个地毯覆盖。若直接模拟每个矩形区域逐格加 \(1\)，时间复杂度 \(O(n^2 m)\) 会超时。利用二维差分可以将每次矩形区域加 \(1\) 的操作降为 \(O(1)\)，再通过一次前缀和还原得到最终覆盖次数。

2. 算法选择：

   • 二维差分：维护差分数组 \(b[i][j]\)，对于每次矩形覆盖 \((x_1,y_1)\) 到 \((x_2,y_2)\)，执行四个差分修改：
     \(b[x_1][y_1] += 1\)
     \(b[x_2+1][y_1] -= 1\)
     \(b[x_1][y_2+1] -= 1\)
     \(b[x_2+1][y_2+1] += 1\)
     最后对 \(b\) 求二维前缀和，即可得到每个格子的覆盖次数。
   • 复杂度：每次修改 \(O(1)\)，最终还原 \(O(n^2)\)，总时间复杂度 \(O(n^2 + m)\)。

3. 关键步骤：

   • 读入与初始化：读取 \(n, m\)，初始化二维差分数组 \(b\) 为 \(0\)。
   • 处理每个矩形：对每个地毯 \((x_1,y_1,x_2,y_2)\)，调用差分修改函数（或直接执行四行修改），注意数组下标从 \(1\) 开始，且需要处理边界防止越界。
   • 前缀和还原：按行按列计算二维前缀和 \(b[i][j] = b[i][j] + b[i-1][j] + b[i][j-1] - b[i-1][j-1]\)，此时 \(b[i][j]\) 即为格子 \((i,j)\) 的实际覆盖次数。
   • 输出：按格式输出 \(n\) 行，每行 \(n\) 个整数。

4. 时间/空间复杂度：

   • 时间复杂度：\(O(n^2 + m)\)。
   • 空间复杂度：\(O(n^2)\)，存储差分数组。

5. 二维差分的核心思想：

   • 差分与前缀和的逆关系：二维差分允许将矩形区间加操作转化为四个角上的单点修改，配合前缀和还原，达到 \(O(1)\) 修改、\(O(n^2)\) 统计的效果。
   • 边界处理：在 \(x_2+1\) 和 \(y_2+1\) 处做减法，确保超出矩形范围的部分不受影响，正确实现区间加。
   • 适用于静态二维区间加、最后查询每个点值的场景，是处理二维覆盖问题的标准技术。

【算法标签】

普及- #差分

【代码详解】

#include <bits/stdc++.h>
using namespace std;

int n, m;                // n: 矩阵大小，m: 操作次数
int a[1005][1005];       // 二维差分数组

int main()
{
    // 输入矩阵大小和操作次数
    cin >> n >> m;

    // 处理每个矩形区域操作
    while (m--)
    {
        int x1, y1, x2, y2;
        cin >> x1 >> y1 >> x2 >> y2;

        // 对每行进行差分处理
        for (int i = x1; i <= x2; i++)
        {
            a[i][y1] += 1;         // 区间起始位置+1
            a[i][y2 + 1] -= 1;     // 区间结束位置+1处-1
        }
    }

    // 计算前缀和并输出结果矩阵
    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= n; j++)
        {
            // 计算前缀和得到最终值
            a[i][j] = a[i][j] + a[i][j - 1];
            cout << a[i][j] << " ";
        }
        cout << endl;
    }

    return 0;
}

// 使用acwing模板二刷
#include <bits/stdc++.h>
using namespace std;

const int N = 1005;  // 定义矩阵最大尺寸
int n, m;           // n: 矩阵大小，m: 操作次数
int a[N][N];        // 原始矩阵（实际未使用）
int b[N][N];        // 二维差分数组

/**
 * 二维差分数组的插入操作
 * @param x1 矩形区域左上角x坐标
 * @param y1 矩形区域左上角y坐标
 * @param x2 矩形区域右下角x坐标
 * @param y2 矩形区域右下角y坐标
 * @param c  要增加的数值
 */
void insert(int x1, int y1, int x2, int y2, int c)
{
    b[x1][y1] += c;         // 左上角+1
    b[x2 + 1][y1] -= c;     // 左下角外侧-1
    b[x1][y2 + 1] -= c;     // 右上角外侧-1
    b[x2 + 1][y2 + 1] += c; // 右下角外侧外侧+1（补偿）
}

int main()
{
    // 输入矩阵大小和操作次数
    cin >> n >> m;

    // 处理每个矩形区域操作
    while (m--)
    {
        int x1, y1, x2, y2;
        cin >> x1 >> y1 >> x2 >> y2;
        insert(x1, y1, x2, y2, 1);  // 对指定区域+1
    }

    // 计算二维前缀和，还原最终矩阵
    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= n; j++)
        {
            b[i][j] += b[i - 1][j] + b[i][j - 1] - b[i - 1][j - 1];
        }
    }

    // 输出结果矩阵
    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= n; j++)
        {
            cout << b[i][j] << " ";
        }
        cout << endl;
    }

    return 0;
}

【运行结果】

5 3
2 2 3 3
3 3 5 5
1 2 1 4
0 1 1 1 0
0 1 1 0 0
0 1 2 1 1
0 0 1 1 1
0 0 1 1 1