最小圆覆盖 gym-102006 I

#include<bits/stdc++.h>
#define LL long long
#define fi first
#define se second
#define mk make_pair
#define PLL pair<LL, LL>
#define PLI pair<LL, int>
#define PII pair<int, int>
#define SZ(x) ((int)x.size())
#define ull unsigned long long
using namespace std;

const int N = 2e5 + ;
const int inf = 0x3f3f3f3f;
const LL INF = 0x3f3f3f3f3f3f3f3f;
const int mod = 1e9 + ;
const double eps = 1.1e-4;
const  double PI = acos(-);

struct Point {
    double x, y;
    Point(double x = , double y = ) : x(x), y(y) { }
};
typedef Point Vector;

int dcmp(double x) {
    if(fabs(x) < eps) return ;
    else return x <  ? - : ;
}

Point operator + (Vector A, Vector B) {return Point(A.x + B.x, A.y + B.y);}
Point operator - (Vector A, Vector B) {return Point(A.x - B.x, A.y - B.y);}
Point operator * (Vector A, double p) {return Point(A.x * p, A.y * p);}
Point operator / (Vector A, double p) {return Point(A.x / p, A.y / p);}
bool operator < (const Vector &A, const Vector &B) {return A.y < B.y || (A.y == B.y && A.x < B.x);}
bool operator == (const Vector &A, const Point &B) {return dcmp(A.x - B.x) ==  && dcmp(A.y - B.y) == ;}
double Dot(Vector A, Vector B) {return A.x * B.x + A.y * B.y;}
double Length(Vector A) {return sqrt(Dot(A, A));}
double Angle(Vector A, Vector B) {return acos(Dot(A, B) / Length(A) / Length(B));}
double Cross(Vector A, Vector B) {return A.x * B.y - A.y * B.x;}
double Area2(Point A, Point B, Point C) {return Cross(B - A, C - A);}

Vector Rotate(Vector A, double rad) {
    return Vector(A.x*cos(rad)-A.y*sin(rad), A.x*sin(rad)+A.y*cos(rad));
}

double dist(const Point& a, const Point &b) {
    return sqrt((a.x-b.x)*(a.x-b.x) + (a.y-b.y)*(a.y-b.y));
}

int n;
double r, R;
Point p[N];

Point GetCircleCenter(Point A, Point B, Point C) {
    Point o;
    double a1 = B.x-A.x, b1 = B.y-A.y, c1 = (a1*a1+b1*b1)/;
    double a2 = C.x-A.x, b2 = C.y-A.y, c2 = (a2*a2+b2*b2)/;
    double d = a1*b2-a2*b1;
    o.x=A.x+(c1*b2-c2*b1)/d;
    o.y=A.y+(a1*c2-a2*c1)/d;
    return o;
}

void MinPointCoverByCircle(Point *p, int n, Point &o, double &r) {
    random_shuffle(p, p+n);
    o = p[], r = ;
    for(int i = ; i < n; i++) {
        if(dist(p[i], o) > r + eps) {
            o = p[i]; r = ;
            for(int j = ; j < i; j++) {
                if(dist(p[j], o) > r + eps) {
                    o.x = (p[i].x+p[j].x)/;
                    o.y = (p[i].y+p[j].y)/;
                    r = dist(p[j], o);
                    for(int k = ; k < j; k++) {
                        if(dist(p[k], o) > r + eps) {
                            o = GetCircleCenter(p[i], p[j], p[k]);
                            r = dist(p[i], o);
                        }
                    }
                }
            }
        }
    }
}

int main() {
//    freopen("robots.in", "r", stdin);
    int T; scanf("%d", &T);
    while(T--) {
        scanf("%d%lf%lf", &n, &R, &r); n++;
        p[] = Point(, );
        for(int i = ; i < n; i++) {
            double x, y; scanf("%lf%lf", &x, &y);
            p[i] = p[i-] + Point(x, y);
        }
        sort(p, p+n);
        n = unique(p, p+n)-p;
        Point o;
        MinPointCoverByCircle(p, n, o, r);
        printf("%.12f %.12f\n", -o.x, -o.y);
    }
    return ;
}
/*
*/