区间覆盖判断;二分查找思想;归并思想;排序思想;

#include <stdio.h>
#include <stdlib.h>

typedef struct
{
int x,y;
}Part;

int main()
{
int n;
Part source;
Part *obj;
scanf("%d",&n);
scanf("%d%d",&source.x,&source.y);
obj=(Part*)malloc(sizeof(Part)*n);
for(int i=0;i<n;++i)
{
scanf("%d%d",&obj[i].x,&obj[i].y);
}
int compare(const void *,const void *);
qsort(obj,n,sizeof(Part),compare);
bool canLoad(Part *,Part,int n);
bool flag=canLoad(obj,source,n);
if(flag==true)
{
printf("能够覆盖!");
}
else
{
printf("休想覆盖!");
}
return 0;
}

bool canLoad(Part *obj,Part source,int n)
{
//合并区间
int i=0,j=1;
while(j<n)
{
if(obj[j].x<=obj[i].y)
{
obj[i].y=obj[j].y;
}
else
{
++i;
obj[i].x=obj[j].x;
obj[i].y=obj[j].y;
}
++j;
}
int s=0,e=i;
//二分查找所有区间
while(s<=e)
{
int middle=(s+e)/2;
if(obj[middle].x<=source.x&&source.y<=obj[middle].y) //目标区间在范围内
{
return true;
}
else if(source.y<obj[middle].x)
{
e=middle-1;
}
else if(source.x>obj[middle].y)
{
s=middle+1;
}
else
{
return false;
}
}
}

int compare(const void *p,const void *q)
{
Part *a=(Part*)p;
Part *b=(Part*)q;
if((*a).x<(*b).x)
{
return -1;
}
else if((*a).x==(*b).x)
{
if(a->y<b->y)
{
return -1;
}
if(a->y==b->y)
{
return 0;
}
if(a->y>b->y)
{
return 1;
}
}
else
{
return 1;
}
}

 

简单描述问题: 给一个源区间,给一堆目标区间. 问目标区间能否覆盖源区间.

 

算法: 先按坐标对所有目标区间排序，然后使用一个归并技巧, 把重合与相邻的区间合并到一起,最后进行区间的二分查找.

 

排序使用快排,先根据x排,x相同按y排.

归并利用两个指针i,j,j总是指向当前要归并的区间,i总是指向被归并于的区间.

j不断向后移动,如果j指向的区间的开始小于等于i区间的结束,那么就把j区间归并给i，继续判断++j;

如果j区间的开始大于i区间的结束,OK,两个区间合并不起来,只要把++i,然后把j区间复制给++i区间,++j继续归并就可以了.线性时间可以完成.

 

二分查找,由于归并结束以后的区间都是间断开的,所以进行二分查找,如果middle区间包含了源区间,OK,可以覆盖. 否则,有3种情况:

1.源区间的y小于middle区间的x， 那么可以去前半区继续查找，即s到 middle-1里去二分查找.  如果源区间的x大于middle区间的y，那么去后半区查找,即middle+1 到e.  其他情况，均说明无法覆盖.