【NOIP2002】矩形覆盖 DFS

最新推荐文章于 2022-08-16 19:10:37 发布

空灰冰魂

最新推荐文章于 2022-08-16 19:10:37 发布

阅读量2.4k

点赞数 1

分类专栏：搜索计算几何 NOIP 文章标签： NOIP2002 矩形覆盖

本文链接：https://blog.csdn.net/Vmurder/article/details/40422103

版权

搜索同时被 3 个专栏收录

18 篇文章 0 订阅

订阅专栏

计算几何

9 篇文章 0 订阅

订阅专栏

NOIP

9 篇文章 0 订阅

订阅专栏

本文介绍了NOIP2002竞赛中关于矩形覆盖的问题，强调K值小于等于3，可以使用DFS暴力求解。作者提供了一种简单易懂的解决方案，通过新开矩形并拆分原有矩形的x或y域来实现。虽然方法适用于K=4的情况，但对于较大的K值可能不适用。建议读者结合代码理解详细步骤。

摘要由CSDN通过智能技术生成

首先大家怒搜就好了，因为虽然说K<=4，实际上K是小于等于3的。

当然某些K<=3还600ms的我就不加评论了。

好吧，但是怎么搜呢？我们考虑到矩形数量很少，所以可以怒搜矩形。

一些神做法我在这里就先不说了，我先说一种简单好写，K=4也能过的沙茶做法。

我们可以开一个结构体存矩形，如：

struct Point{int x,y;};
int cmpx(Point a,Point b){return a.x<b.x;}
int cmpy(Point a,Point b){return a.y<b.y;}
struct Mrx
{
	Point px[N],py[N];
	int n;
}mrx[10];

然后大家看到我开了10个mrx，现在就有一个性质：每一层的矩形编号都是基本固定的，都是上一层的全部矩形加上这一层多出来的两个矩形然后去掉被拆分的矩形。这个可以用一些pre数组神马的啊处理出来那些矩形被拆分过。然后总矩形数不会超过dep*2，枚举起来时间复杂度非常小。

当然，lazy的我肯定没开这个pre数组，我利用K<=3的小性质直接传了一个参，说上一层哪个被拆了，然后快速水过，当K比较大时这是错的，看代码时不要吐槽~~，毕竟K就这么小。

然后怎么拆分呢？就是新开两个矩形，把旧矩形的点扔到新的两个矩形中，每次拆分的思想都是把x的域拆成两个，或者把y的域拆成两个。

太沙茶了，没看懂的赶紧看代码吧。

#include <cstdio>
#include <cstring>
#include <algorithm>
#define N 55
#define inf 0x3f3f3f3f
using namespace std;
struct Point{int x,y;};
int cmpx(Point a,Point b){return a.x<b.x;}
int cmpy(Point a,Point b){return a.y<b.y;}
struct Mrx
{
	Point px[N],py[N];
	int n;
}mrx[10];
int n,m,ans=inf;

void dfs(int dep,int from)
{
	int t_ans=0,i,j,k,to;
	int sta=max(1,dep-2<<1),end=dep*2-1;
	for(i=sta;i<=end;i++)if(i!=from)t_ans+=(mrx[i].px[mrx[i].n].x-mrx[i].px[1].x)*(mrx[i].py[mrx[i].n].y-mrx[i].py[1].y);
	ans=min(t_ans,ans);
	if(!ans)return ;
	if(dep==m)return ;
	for(i=sta;i<=end;i++)if(i!=from)
	{
		for(j=1;j<mrx[i].n;j++)
		{
			if(mrx[i].px[j].x!=mrx[i].px[j+1].x)/*切x*/
			{
				to=dep*2;
				mrx[to].n=j;
				for(k=1;k<=mrx[to].n;k++)
				{
					mrx[to].px[k].x=mrx[to].py[k].x=mrx[i].px[k].x;
					mrx[to].px[k].y=mrx[to].py[k].y=mrx[i].px[k].y;
				}
				sort(mrx[to].px+1,mrx[to].px+mrx[to].n+1,cmpx);
				sort(mrx[to].py+1,mrx[to].py+mrx[to].n+1,cmpy);
				to=dep*2+1;
				mrx[to].n=mrx[i].n-j;
				for(k=1;k<=mrx[to].n;k++)
				{
					mrx[to].px[k].x=mrx[to].py[k].x=mrx[i].px[k+j].x;
					mrx[to].px[k].y=mrx[to].py[k].y=mrx[i].px[k+j].y;
				}
				sort(mrx[to].px+1,mrx[to].px+mrx[to].n+1,cmpx);
				sort(mrx[to].py+1,mrx[to].py+mrx[to].n+1,cmpy);
				dfs(dep+1,i);
			}
			if(mrx[i].py[j].y!=mrx[i].py[j+1].y)/*切y*/
			{
				to=dep*2;
				mrx[to].n=j;
				for(k=1;k<=mrx[to].n;k++)
				{
					mrx[to].px[k].x=mrx[to].py[k].x=mrx[i].py[k].x;
					mrx[to].px[k].y=mrx[to].py[k].y=mrx[i].py[k].y;
				}
				sort(mrx[to].px+1,mrx[to].px+mrx[to].n+1,cmpx);
				sort(mrx[to].py+1,mrx[to].py+mrx[to].n+1,cmpy);
				to=dep*2+1;
				mrx[to].n=mrx[i].n-j;
				for(k=1;k<=mrx[to].n;k++)
				{
					mrx[to].px[k].x=mrx[to].py[k].x=mrx[i].py[k+j].x;
					mrx[to].px[k].y=mrx[to].py[k].y=mrx[i].py[k+j].y;
				}
				sort(mrx[to].px+1,mrx[to].px+mrx[to].n+1,cmpx);
				sort(mrx[to].py+1,mrx[to].py+mrx[to].n+1,cmpy);
				dfs(dep+1,i);
			}
		}
	}
}


int main()
{
//	freopen("test.in","r",stdin);
	int i,j,k;
	int a,b,c;
	scanf("%d%d",&n,&m);
	mrx[1].n=n;
	for(i=1;i<=n;i++)
	{
		scanf("%d%d",&a,&b);
		mrx[1].px[i].x=mrx[1].py[i].x=a;
		mrx[1].px[i].y=mrx[1].py[i].y=b;
	}
	sort(mrx[1].px+1,mrx[1].px+n+1,cmpx);
	sort(mrx[1].py+1,mrx[1].py+n+1,cmpy);
	dfs(1,0);
	printf("%d\n",ans);
	return 0;
}

这里我再引用一个特别的作死技巧：DP？！！！我表示我没看懂也不想看懂，毕竟网上有个文库好像是先提出这种算法，但是他说好像不能覆盖所有情况，可能算是有些cheat的成分吧，所以还是不看了。

来源：http://www.cnblogs.com/noip/archive/2012/08/13/2635815.html

#include<iostream>
#define Max 1000000
using namespace std;

int n,m,ans=Max,x[52],y[52],f[52][52][5]={0};

int High(int i,int j){
    int maxh=0,minh=1000,temp=i;
    while(temp<=j)
    maxh=max(maxh,y[temp++]);
    temp=i;
    while(temp<=j)
    minh=min(minh,y[temp++]);
    return maxh-minh;
    }


void Dp(){
     for(int i=1;i<=n;++i)
     for(int j=1;j<=n;++j)
     for(int k=2;k<=m;++k)
     f[i][j][k]=Max;
     
     for(int i=1;i<=n;++i)
     for(int j=i+1;j<=n;++j)
     f[i][j][1]=(x[j]-x[i])*High(i,j);
     for(int i=1;i<=n;++i)
     for(int k=1;k<=m;++k)
     f[i][i][k]=0;
     
     for(int k=2;k<=m;++k)
     for(int i=1;i<=n;++i)
     for(int j=i+1;j<=n;++j)
     for(int l=i+1;l<=j;++l)
     f[i][j][k]=min(f[i][j][k],f[i][l-1][k-1]+(x[j]-x[l])*High(l,j));

     ans=min(ans,f[1][n][m]);
     }

int main()
{
    cin>>n>>m;
    for(int i=1;i<=n;++i)
    cin>>x[i]>>y[i];
    
    for(int i=1;i<=n;++i)
    for(int j=i+1;j<=n;++j)
    if(x[i]>x[j]) {swap(x[i],x[j]);swap(y[i],y[j]);}
    else if(x[i]==x[j]&&y[i]>=y[j]) swap(y[i],y[j]);
    
    Dp();    
    
    for(int i=1;i<=n;++i)
    swap(x[i],y[i]);
    
    for(int i=1;i<=n;++i)
    for(int j=i+1;j<=n;++j)
    if(x[i]>x[j]) {swap(x[i],x[j]);swap(y[i],y[j]);}
    else if(x[i]==x[j]&&y[i]>=y[j]) swap(y[i],y[j]);
    
    Dp();    
    
    cout<<ans<<endl;
    return 0;
    
    }

复制去Google翻译翻译结果