HDU 1007

题目大意是这样的：

在坐标轴上给定一些点，求出这些点中距离最近的两个点之间的距离。最后输出的结果是 距离的一半

分析：

只要将这些点按照横坐标从小到大排序，相同的话，按照纵坐标从小到大排序，求出每两点之间最小的距离len1;

        然后按照纵坐标从小到大排序，相同的话，按照横坐标从小到大排序，求出每两点之间最小的距离len2;

        最终的结果就是 min(len1,len2)

  

这道题在编写的时候遇到两个问题：

1. distance函数，出现命名冲突，解决方案是在自己重新定义distance引用之前加上：：,后者直接把 distance 改一个名字就可。

2. 刚开始使用 冒泡排序，结果超时，O(N*N), 改进方法是调用algorithm里的sort算法，才解决这个问题。

思考：sort算法的时间复杂度是多少？

这里比较sort 与 快速排序：

std::sort使用的算法在大多数情况下都比quick sort算法要快，并且，在quick sort越慢的情况下越明显。Quick sort 平均情况下为O( NlogN ) ，在最坏情况下为 O (N^2)。 而std::sort是针对Quick sort最坏情况做的改进，从而保持了 O(NlogN) 的复杂度。

//
//  main.cpp
//  Demo
//
//  Created by Jaster_chen on 1/27/16.
//  Copyright © 2016 Jaster_chen. All rights reserved.
//

#include<iostream>
#include<iomanip>
#include<math.h>
#include<algorithm>
using namespace std;

struct Point
{
    double x;
    double y;
}P[100001];

double distance(Point P1, Point P2)
{
    return sqrt(pow(P1.x-P2.x,2)+pow(P1.y-P2.y,2));
}

bool cmp1(const Point a,const Point b)
{
    if(a.x<b.x)
        return true;
    if(a.x>b.x)
        return false;
    else
        return a.y<b.y;
}

bool cmp2(const Point a,const Point b)
{
    if(a.y<b.y)
        return true;
    if(a.y>b.y)
        return false;
    else
        return a.x<b.x;
}

int main()
{
    double len1,len2;
    int N;
    while(cin>>N&&N!=0)
    {
        for(int i=1;i<=N;i++)
        {
            cin>>P[i].x>>P[i].y;
        }
        sort(P+1,P+N+1,cmp1);
        double min = ::distance(P[1],P[2]);
        double dis;
        for(int i=2;i<N;i++)
        {
            dis = ::distance(P[i],P[i+1]);
            if(dis<min)
                min = dis;
        }
        len1 = min/2.0;
        sort(P+1,P+N+1,cmp2);
        double Min = ::distance(P[1],P[2]);
        double Dis;
        for(int i=2;i<N;i++)
        {
            Dis = ::distance(P[i],P[i+1]);
            if(Dis<Min)
                Min = Dis;
        }
        len2 = Min/2.0;
        if(len1>len2)   len1 = len2;
        cout<<fixed<<setprecision(2)<<len1<<endl;
    }
    return 0;
}

但是 此题后来感觉解法有问题：

A(1,100),B(100,1),C(1,1),D(2,2).
①按照每个点 x 值由小到大进行排序，若 x 相同，则按照 y 由小到大进行排序，计算相邻两点的最短距离，即为len1。
那么排序结果为：C(1,1),A(1,100),D(2,2),B(100,1).
CA的距离为99，AD的距离为根号下（1+98^2）（约等于98，以下我都按98算），DB的距离约等于98，最小值为AD或DB的距离98，故len1=98。

②按照每个点 y 值由小到大进行排序，若 y 相同，则按照 x 由小到大进行排序，计算相邻两点的最短距离，即为len2。
那么排序结果为：C(1,1),B(100,1),D(2,2),A(1,100).
CB的距离为99，BD的距离约等于98，DA的距离约为98，最小值为BD或DA的距离98，故len2=98.

按照思路，答案即为：min（len1，len2），也就是98。

但是明显这里最短的距离是CD的距离：根号2，而这种思路算不到这种情况，所以是不正确的
稳妥的方法却会时间超限