Hrbust 1619 只有矩形【逆序思维+枚举+并查集优化】

只有矩形

Time Limit: 1000 MS Memory Limit: 131072 K Total Submit: 19(10 users) Total Accepted: 12(8 users) Rating:  Special Judge: No

Description

一块屏幕上有n*m个像素，需要画q个矩形，每次绘画矩形的命令如下：xc yc l w c，即把屏幕  xc ≤ x ≤ xc+l-1, yc ≤ y ≤ yc+w-1的区域涂上c颜色，也就是画了一个c颜色的矩形。总共有9中颜色。 后画的矩形会把先画的矩形覆盖掉。当画完所有的q个矩形后，要你求出每种颜色的像素个数。 数据范围：n<=200, m<=50000, q <= 50000。

Input

有多组测试数据。 对于每组测试数据，第一行为n m q，表示屏幕大小为n*m，总共画q个矩形。 接下来有q行，按输入顺序画矩形，每行输入格式为 xc yc l w c。 输入数据保证合法。

Output

对于每组测试数据，输出一行用空格隔开的9个数，分别表示1~9种颜色的的像素个数。

Sample Input

8 10 3 3 4 1 6 9 4 6 2 3 1 1 9 4 1 3 4 5 3 0 4 4 1 6 3 4 1 1 2 2 4 2 1 4

Sample Output

6 0 4 0 0 0 0 0 5 0 0 0 2 0 2 0 0 0

思路：

观察到N的范围并不大，所以我们可以将所有查询分成一行一行去处理。

所以对于当前一行row.我们逆序涂色，如果涂色区域包含当前行row.那么可以进行涂色处理。

如果我们这里O（m）去涂色的话，肯定是要超时的，所以这里考虑并查集优化。

初始化设定f【i】=i，对于一片涂色区域，【L,R】，初始的时候肯定没有被涂色，那么我们涂色过程中，使得L~R区间内的所有点都合并在一起，并且让大标号的作为父亲节点，那么如果我们处理一片涂色区域【Li，Ri】的时候，如果此时有位子被之前涂过色了，那么我们逆序处理的时候肯定就不用处理这部分了，我们跳过这部分使得涂色到的当前点now=find（now）+1即可。

我们一边涂色一边合并点，那么我们能够优化掉超级多的繁杂步骤。

过程维护并查集和最终答案即可。

Ac代码：

#include<stdio.h>
#include<string.h>
using namespace std;
struct node
{
int x,y,lx,ly,c;
}q[50500];
int a[50050];
int ans[20];
int f[50050];
int find(int a)
{
int r=a;
while(f[r]!=r)
r=f[r];
int i=a;
int j;
while(i!=r)
{
j=f[i];
f[i]=r;
i=j;
}
return r;
}
void merge(int a,int b)
{
int A,B;
A=find(a);
B=find(b);
if(A!=B)
{
if(B>A)
{
f[A]=B;
}
else f[B]=A;
}
}
int main()
{
int n,m,qq;
while(~scanf("%d%d%d",&n,&m,&qq))
{
memset(ans,0,sizeof(ans));
for(int i=0;i<qq;i++)
{
scanf("%d%d%d%d%d",&q[i].x,&q[i].y,&q[i].lx,&q[i].ly,&q[i].c);
}
for(int i=0;i<n;i++)
{
for(int j=0;j<m;j++)f[j]=j,a[j]=0;
for(int j=qq;j>=0;j--)
{
if(q[j].x<=i&&i<=q[j].x+q[j].lx-1)
{
int now=q[j].y;
while(now<=q[j].y+q[j].ly-1)
{
if(a[now]==0)
{
a[now]=q[j].c;
ans[q[j].c]++;
now++;
}
else
{
now=find(now)+1;
}
if(now<=q[j].y+q[j].ly-1)merge(now,now-1);
}
}
}
}
for(int i=1;i<=9;i++)
{
if(i>1)printf(" ");
printf("%d",ans[i]);
}
printf("\n");
}
}