洛谷 P1429 平面最近点对（加强版）分治/暴力+二分

https://www.luogu.com.cn/problem/P1429

思路一：正经解法：分治。首先把$n$个点按照$x$排序，每次按照$p[mid].x$把点集分成两部分，$solve(l,mid)、solve(mid+1,r)$得到每一部分点对之间的最小值$ans$。那么总体最小值要么等于$ans$，要么等于左右两部分各选一个点组成的点对之间的距离。现在考虑后半部分怎么算，暴力枚举肯定是不行的，我们可以利用已知信息——$ans$来入手，显然可以把需要考虑的点的$x$的范围限定到$[p[mid].x-ans,p[mid].x+ans]$，此时画图可以知道对于任意一个位于该范围内的点$i$，满足$p[j].y-p[i].y<ans$的点$j$的数量不超过$6$个，那么只要我们把这个范围内的点按照$y$排序后，就可以在$O(n)$内通过枚举得到结果。但是这样复杂度是$O(nl{g}^{2}n)$的，还可以再优化吗？可以，按照$y$排序的过程没必要利用$sort$来实现，我们这个过程本来就是递归求解的，所以可以直接利用归并排序的$Merge$过程实现排序，这样复杂度就降到$O(nlgn)$了，同时为了减少$sqrt$运算，代码中使用的是距离的平方进行比较，看代码的时候要注意一下~。

#include<bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;
using ll=long long;

const int maxn=2e5+5;

struct point
{
    ll x,y;
    point(){}
    point(ll x,ll y):x(x),y(y){}
    bool operator <(const point &a)const
    {
        if(x==a.x)
            return y<a.y;
        return x<a.x;
    }
}p[maxn],tmp[maxn];

int n;
int idx[maxn];

inline ll dis(point a,point b)
{
    return (a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y);
}

inline void Merge(int l,int mid,int r)//归并排序
{
    int i=l,j=mid+1,k=l;
    while(i<=mid&&j<=r)
    {
        if(p[i].y<=p[j].y)//按照y
            tmp[k++]=p[i++];
        else
            tmp[k++]=p[j++];
    }
    while(i<=mid)
        tmp[k++]=p[i++];
    while(j<=r)
        tmp[k++]=p[j++];
    for(int i=l;i<=r;i++)
        p[i]=tmp[i];
}

ll solve(int l,int r)
{
    if(l==r)//一个点
        return 2e18; //返回一个无意义的极限值
    if(l+1==r)//两个点
    {
        if(p[l].y>p[r].y)//别忘了这一步
            swap(p[l],p[r]);
        return dis(p[l],p[r]);
    }
    int mid=(l+r)>>1;
    ll base=p[mid].x; //记录基准值
    ll ans=solve(l,mid);
    ans=min(ans,solve(mid+1,r));
    Merge(l,mid,r); //按y进行归并排序
    int cnt=0;
    ll v;
    for(int i=l;i<=r;i++)
    {
        v=abs(base-p[i].x);
        v*=v;
        if(v<ans)
            idx[++cnt]=i; //计算出位于所限制区间内的点
    }
    for(int i=1;i<=cnt;i++)
    {
        for(int j=i+1;j<=cnt;j++)
        {
            v=abs(p[idx[j]].y-p[idx[i]].y);
            v*=v;
            if(v>=ans)
                break;  //只计算纵坐标之差的绝对值小于预定值 的点对
            ans=min(ans,dis(p[idx[i]],p[idx[j]]));
        }
    }
    return ans;
}

int main()
{
    scanf("%d",&n);
    for(int i=0;i<n;i++)
        scanf("%lld %lld",&p[i].x,&p[i].y);
    sort(p,p+n);
    printf("%.4f\n",sqrt(solve(0,n-1)));
    return 0;
}

思路二：暴力+二分剪枝。首先还是要对$n$个点按照$x$排序，然后枚举每一个点，因为已知距离最小值为$ans$，所以在枚举第$i$个点的时候，可以把$x$限制在$[p[i].x-ans,p[i].x+ans]$之内，因为点集按照$x$是有序的，所以我们可以通过二分找到这个限制所对应的区间$[l,r]$，然后计算$i$和$[l,r]$之间的点对的距离。这个复杂度就比较玄学了，不过还是可以$A$掉这道题的，而且代码非常好写。

#include<bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;
using ll=long long;

const int maxn=2e5+5;

struct point
{
    ll x,y;
    point(){}
    point(ll x,ll y):x(x),y(y){}
    bool operator <(const point &a)const
    {
        if(x==a.x)
            return y<a.y;
        return x<a.x;
    }
}p[maxn];

int n;

inline double dis(point a,point b)
{
    return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));
}

int main()
{
    scanf("%d",&n);
    for(int i=0;i<n;i++)
        scanf("%lld %lld",&p[i].x,&p[i].y);
    sort(p,p+n);
    double ans=2e9;
    int l,r;
    point base(0,0);
    for(int i=0;i<n;i++)
    {
        base.x=p[i].x-ans-1;
        l=lower_bound(p,p+n,base)-p;
        base.x=p[i].x+ans+1;
        r=upper_bound(p,p+n,base)-p-1;
        while(l<=r)
        {
            if(i==l)
                ++l;
            else
                ans=min(ans,dis(p[i],p[l++]));
        }
    }
    printf("%.4f\n",ans);
    return 0;
}