PA2019 Terytoria

洛谷P5987 [PA2019] Terytoria

题目大意

在一个平面直角坐标系上，有一个长度为$X$，宽度为$Y$的地图，这个地图的左边界和右边界是连通的，下边界和上边界也是连通的。

在地图中，有$X\times Y$个格子以及$n$个矩形，这些矩形的边与坐标轴平行。你只知道每个矩形两个对顶点的坐标，求被所有矩形覆盖住的格子数量的最大值？

$1\le n\le 5\times 10^5,2\le X,Y\le 10^9$

题解

因为每个矩形在横坐标上是取两边或中间，在纵坐标上也是取两边或中间，所以横坐标和纵坐标是不相关的。我们把这些矩形分成映射在$x$轴的线段和映射在$y$轴的线段，则最终的答案为$x$轴上能被所有线段覆盖的最大长度$\times y$轴上能被所有线段覆盖的最大长度。那么，我们就可以将横坐标和纵坐标分开来做。

对横纵坐标进行离散化，对于离散化后的两个相邻的离散点连成的线段。那么，每种线段只有唯一的取法（取中间或者两边）才能覆盖这条由两个离散点连成的线段。我们用$01$状态来表示每个矩形的覆盖情况（$0$表示取两边，$1$表示取中间），状态可以用哈希和差分来维护，然后用哈希表来存储对应状态的长度，边维护边取最大值。

时间复杂度为$O(n\log n+P)$，其中$P$为哈希表的大小。

code

#include
using namespace std;
const int N=500000,P=19260817,base=7;
const long long mod1=998244353,mod2=1e9+7;
int n,X,Y,tot=0,l[2*N+5],r[P+5],hv[2*N+5],w1[2*N+5],w2[2*N+5];
long long re,ans=0,pw1[N+5],pw2[N+5];
struct node{
	int x,w,id;
}x[2*N+5],y[2*N+5];
bool cmp(node ax,node bx){
	return ax.x<bx.x;
}
void add(int x,int h1,int h2,int vt){
	l[++tot]=r[x];
	w1[tot]=h1;w2[tot]=h2;hv[tot]=vt;
	r[x]=tot;
}
void pl(int h1,int h2,int vt){
	int u=h1%P;
	for(int i=r[u];i;i=l[i]){
		if(w1[i]==h1&&w2[i]==h2){
			hv[i]+=vt;
			re=max(re,1ll*hv[i]);
			return;
		}
	}
	add(u,h1,h2,vt);
	re=max(re,1ll*vt);
}
long long solve(node *a,int mx){
	memset(r,0,sizeof(r));
	re=0;tot=0;
	long long h1=0,h2=0;
	pl(0,0,a[1].x);
	for(int i=1;i<2*n;i++){
		h1=(h1+pw1[a[i].id]*a[i].w+mod1)%mod1;
		h2=(h2+pw2[a[i].id]*a[i].w+mod2)%mod2;
		pl(h1,h2,a[i+1].x-a[i].x);
	}
	pl(0,0,mx-a[2*n].x);
	return re;
}
int main()
{
//	freopen("globe.in","r",stdin);
//	freopen("globe.out","w",stdout);
	scanf("%d%d%d",&n,&X,&Y);
	for(int i=1,dx,dy,ux,uy;i<=n;i++){
		scanf("%d%d%d%d",&dx,&dy,&ux,&uy);
		if(dx>ux) swap(dx,ux);
		if(dy>uy) swap(dy,uy);
		x[i*2-1]=(node){dx,1,i};
		x[i*2]=(node){ux,-1,i};
		y[i*2-1]=(node){dy,1,i};
		y[i*2]=(node){uy,-1,i};
	}
	sort(x+1,x+2*n+1,cmp);
	sort(y+1,y+2*n+1,cmp);
	pw1[0]=pw2[0]=1;
	for(int i=1;i<=N;i++){
		pw1[i]=pw1[i-1]*base%mod1;
		pw2[i]=pw2[i-1]*base%mod2;
	}
	ans=solve(x,X)*solve(y,Y);
	printf("%lld",ans);
	return 0;
}