hdu 1007 Quoit Design 题解

原题地址

题目大意

查询平面内最近点对的距离，输出距离的一半。

暴力做法

枚举每一个点对的距离直接判断，时间复杂度是 $ O(n^2) $，对于这题来说会超时。

那么我们考虑去优化这一个过程，我们在求距离的过程中其实有很多的计算是没有必要的，比如已经有一个暂时的最小值 $ d $，如果有 $ dis>d $，那么这个 $ dis $ 是没有贡献的，那么我们怎么除去这些不必要的答案呢？

我们可以考虑分治，假设已经求出了两个小区间 $ A , B $ 的最小值，那么合并的大区间 $ C $ 的最小值实际上就是在 $ d=n(A,B) $ 和A，B中的点对构成的距离中取最小值，那么我们可以用上之前的那个优化，对于大于d的我们不去选择，那么就可以缩小我们所需要的计算量，由于鸽巢原理只我们最多只要求36个点对，计算量很小。

然后我就开始敲代码了，一开始的代码是这样的

#include<bits/stdc++.h>
using namespace std;
const int maxn=100010;
const double INF=100000000.0;
struct node{
    double x;
    double y;
}a[maxn];
int n,tail1,tail2,tmp1[maxn],tmp2[maxn];
double ans;
bool cmp(node i,node j){
    return i.x<j.x;
}
double dis(int i,int j){
    double ans=sqrt((a[i].x-a[j].x)*(a[i].x-a[j].x)+(a[i].y-a[j].y)*(a[i].y-a[j].y));
    return ans;
}
double clu(int l,int r){
    if(l==r) return INF;
    int mid=(l+r)>>1;
    double d=min(clu(l,mid),clu(mid+1,r));
    tail1=0;tail2=0;
    for(int i=mid;i>=l&&a[mid].x-a[i].x<d;--i) tmp1[++tail1]=i;
    for(int i=mid+1;i<=r&&a[i].x-a[mid].x<d;++i) tmp2[++tail2]=i;
    for(int i=1;i<=tail1;++i){
        for(int j=1;j<=tail2;++j){
            double k=dis(tmp1[i],tmp2[j]);
            if(d>k&&tmp1[i]!=tmp2[j]) d=k;
        }
    }
    return d;
}
int main(){
    scanf("%d",&n);
    while(n){
        memset(a,0,sizeof(a));
        for(int i=1;i<=n;++i){
            scanf("%lf %lf",&a[i].x,&a[i].y);
        }
        sort(a+1,a+1+n,cmp);
        ans=clu(1,n)/2.0;
        printf("%.2lf
",ans);
        scanf("%d",&n);    
    }
    return 0;
}

然后时间超限，（雾

后面发现问题出在我只判断了x是否大于d，但对于y并没有去进行判断，这就导致时间复杂度还是很高，其实只要对y进行排序再剪枝便可AC

代码

#include<bits/stdc++.h>
using namespace std;
const int maxn=100010;
const double INF=100000000.0;
struct node{
    double x;
    double y;
}a[maxn];
int n,tail,tmp[maxn];
double ans;
bool cmp1(node i,node j){
    return i.x<j.x;
}
bool cmp2(int i,int j){
    return a[i].y<a[j].y;
}
double dis(int i,int j){
    double ans=sqrt((a[i].x-a[j].x)*(a[i].x-a[j].x)+(a[i].y-a[j].y)*(a[i].y-a[j].y));
    return ans;
}
double clu(int l,int r){
    if(l==r) return INF;
    int mid=(l+r)>>1;
    double d=min(clu(l,mid),clu(mid+1,r));
    tail=0;
    for(int i=mid;i>=l&&a[mid].x-a[i].x<d;--i) tmp[++tail]=i;
    for(int i=mid+1;i<=r&&a[i].x-a[mid].x<d;++i) tmp[++tail]=i;
    sort(tmp+1,tmp+tail+1,cmp2);
    for(int i=1;i<=tail;++i){
        for(int j=i+1;j<=tail && a[tmp[j]].y-a[tmp[i]].y<d;++j){
            double k=dis(tmp[i],tmp[j]);
            if(d>k&&tmp[i]!=tmp[j]) d=k;
        }
    }
    return d;
}
int main(){
    scanf("%d",&n);
    while(n){
        memset(a,0,sizeof(a));
        for(int i=1;i<=n;++i){
            scanf("%lf %lf",&a[i].x,&a[i].y);
        }
        sort(a+1,a+1+n,cmp1);
        ans=clu(1,n)/2.0;
        printf("%.2lf
",ans);
        scanf("%d",&n);    
    }
    return 0;
}

可以对照一下这两个代码，关键部分便在于

	for(int i=1;i<=tail;++i){
		for(int j=i+1;j<=tail && a[tmp[j]].y-a[tmp[i]].y<d;++j){
			double k=dis(tmp[i],tmp[j]);
			if(d>k&&tmp[i]!=tmp[j]) d=k;
		}
	}

值得注意的是

a[tmp[j]].y-a[tmp[i]].y<d

必须放在循环的判断条件里，而不可以拖进来，否则仍然超时，原因便在我们对y进行了排序，那么如果 $ a[tmp[j]].y-a[tmp[i]].y>=d $ 那么 $ tmp[k]].y-a[tmp[i]].y>=d , k>j $ 可以达到剪枝的效果。

完结撒花！