求最远点对，输出距离

#include<iostream>
#include <math.h>
#include <algorithm>
#include<stdio.h>

using namespace std;

#define eps 1e-8
#define zero(x) (((x)>0?(x):-(x))<eps)
struct point{ double x, y; }p[100005], convex[100005];

double xmult(point p1, point p2, point p0)
{
    return (p1.x - p0.x)*(p2.y - p0.y) - (p2.x - p0.x)*(p1.y - p0.y);
}

int dist2(point a, point b)
{
    return (a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y);
}

point p1, p2;
int graham_cp(const void* a, const void* b){
    double ret = xmult(*((point*)a), *((point*)b), p1);
    return zero(ret) ? (xmult(*((point*)a), *((point*)b), p2) > 0 ? 1 : -1) : (ret > 0 ? 1 : -1);
}
void _graham(int n, point* p, int& s, point* ch){
    int i, k = 0;
    for (p1 = p2 = p[0], i = 1; i<n; p2.x += p[i].x, p2.y += p[i].y, i++)
    if (p1.y - p[i].y>eps || (zero(p1.y - p[i].y) && p1.x > p[i].x))
        p1 = p[k = i];
    p2.x /= n, p2.y /= n;
    p[k] = p[0], p[0] = p1;
    qsort(p + 1, n - 1, sizeof(point), graham_cp);
    for (ch[0] = p[0], ch[1] = p[1], ch[2] = p[2], s = i = 3; i < n; ch[s++] = p[i++])
    for (; s>2 && xmult(ch[s - 2], p[i], ch[s - 1]) < -eps; s--);
}

int wipesame_cp(const void *a, const void *b)
{
    if ((*(point *)a).y < (*(point *)b).y - eps) return -1;
    else if ((*(point *)a).y >(*(point *)b).y + eps) return 1;
    else if ((*(point *)a).x < (*(point *)b).x - eps) return -1;
    else if ((*(point *)a).x >(*(point *)b).x + eps) return 1;
    else return 0;
}

int _wipesame(point * p, int n)
{
    int i, k;
    qsort(p, n, sizeof(point), wipesame_cp);
    for (k = i = 1; i < n; i++)
    if (wipesame_cp(p + i, p + i - 1) != 0) p[k++] = p[i];
    return k;
}

int graham(int n, point* p, point* convex, int maxsize = 1, int dir = 1){
    point* temp = new point[n];
    int s, i;
    n = _wipesame(p, n);
    _graham(n, p, s, temp);
    for (convex[0] = temp[0], n = 1, i = (dir ? 1 : (s - 1)); dir ? (i < s) : i; i += (dir ? 1 : -1))
    if (maxsize || !zero(xmult(temp[i - 1], temp[i], temp[(i + 1) % s])))
        convex[n++] = temp[i];
    delete[]temp;
    return n;
}

int rotating_calipers(point *ch, int n)
{
    int q = 1, ans = 0;
    ch[n] = ch[0];
    for (int p = 0; p < n; p++)
    {
        while (xmult(ch[p + 1], ch[q + 1], ch[p]) > xmult(ch[p + 1], ch[q], ch[p]))
            q = (q + 1) % n;
        ans = max(ans, max(dist2(ch[p], ch[q]), dist2(ch[p + 1], ch[q + 1])));
    }
    return ans;
}
int main()
{
    int n;
    cin >> n;
    for (int i = 0; i < n; i++)
    {
        scanf("%lf%lf", &p[i].x, &p[i].y);
    }
    int size = graham(n, p, convex, 1, 0);
    //cout << rotating_calipers(convex, size) << endl;
    printf("%.8lf
",sqrt(rotating_calipers(convex, size)));
    return 0;
}