每周一算法：二维差分

题目链接

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)$ 这个格子被多少个地毯覆盖。

样例 #1

样例输入 #1

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

样例输出 #1

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

提示

样例解释

覆盖第一个地毯后：

$0$	$0$	$0$	$0$	$0$
$0$	$1$	$1$	$0$	$0$
$0$	$1$	$1$	$0$	$0$
$0$	$0$	$0$	$0$	$0$
$0$	$0$	$0$	$0$	$0$

覆盖第一、二个地毯后：

$0$	$0$	$0$	$0$	$0$
$0$	$1$	$1$	$0$	$0$
$0$	$1$	$2$	$1$	$1$
$0$	$0$	$1$	$1$	$1$
$0$	$0$	$1$	$1$	$1$

覆盖所有地毯后：

$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$

---

数据范围

对于 $20\%$ 的数据，有 $n\le 50$，$m\le 100$。

对于 $100\%$ 的数据，有 $n,m\le 1000$。

算法思想

根据题目描述，要将$m$块地毯铺在 $n\times n$ 的矩阵上，每块地毯会覆盖从$(x_1,y_1)$到$(x_2,y_2)$一个子矩阵，求最终每个格子被多少个地毯覆盖。

朴素思想是枚举每块地毯，将其覆盖的子矩阵从$(x_1,y_1)$到$(x_2,y_2)$的所有格子地毯数$+1$，时间复杂度为$O(m\times n^2)$，显然是无法满足题目要求的。对于这样问题，可以用二维差分来优化。

二维差分

二维差分基本思想：

• 首先，构造一个$n\times n$的差分矩阵d[n][n]，并将其初始化为$0$。例如，下图是一个$5\times 5$差分矩阵。
  

• 对于每一次操作，如果要将其中一个从$(x_1,y_1)$ 到 $(x_2,y_2)$的子矩阵中所有元素都加上$c$，那么只需要$4$步操作：

  • d[x1][y1] += c
  • d[x1][y2 + 1] -= c
  • d[x2 + 1][y1] -= c
  • d[x2 + 1][y2 +1 ] += c

  例如，对$(2,2)\sim (4,3)$的子矩阵每个元素加上$1$，$4$步操作如下图所示：
  

• 经过$m$次操作后，只需要对差分矩阵求$1$次前缀和，就可以得到所有操作之后的矩阵了。如下图所示：
  
  二维前缀和可以参考博主的另一篇文章：每周一算法：二维前缀和

时间复杂度

• 一共进行$m$次操作，每次操作选择一个子矩阵进行标记，时间复杂度为$O(m)$；
• 操作结束后，对差分矩阵求前缀和，时间复杂度为$O(n^2)$。

代码实现

#include <bits/stdc++.h>
using namespace std;
const int N = 1010;
int d[N][N];

void add(int x1, int y1, int x2, int y2, int c)
{
    d[x1][y1] += c;
    d[x1][y2 + 1] -= c;
    d[x2 + 1][y1] -= c;
    d[x2 + 1][y2 + 1] += c;
}

int main()
{
    int n, m;
    cin >> n >> m;
    while(m --)
    {
        int x1, y1, x2, y2;
        cin >> x1 >> y1 >> x2 >> y2;
        add(x1, y1, x2, y2, 1);
    }
    
    for(int i = 1; i <= n; i ++)
    {
        for(int j = 1; j <= n; j ++)
        {
            d[i][j] += d[i - 1][j] + d[i][j - 1] - d[i - 1][j - 1];
            cout << d[i][j] << " ";
        }
        cout << endl;
    }
    
}