Problem:
Score : 600 points

Problem Statement

Given are N points (x_i, y_i) in a two-dimensional plane.

Find the minimum radius of a circle such that all the points are inside or on it.

Constraints

2 \leq N \leq 50

0 \leq x_i \leq 1000

0 \leq y_i \leq 1000

The given N points are all different.

The values in input are all integers.

Input

Input is given from Standard Input in the following format:

N
x_1 y_1
:
x_N y_N

Output

Print the minimum radius of a circle such that all the N points are inside or on it.

Your output will be considered correct if the absolute or relative error from our answer is at most 10^{-6}.

Sample Input 1

2
0 0
1 0

Sample Output 1

0.500000000000000000

Both points are contained in the circle centered at (0.5,0) with a radius of 0.5.

Sample Input 2

3
0 0
0 1
1 0

Sample Output 2

0.707106781186497524

Sample Input 3

10
10 9
5 9
2 0
0 0
2 7
3 3
2 5
10 0
3 7
1 9

Sample Output 3

6.726812023536805158

If the absolute or relative error from our answer is at most 10^{-6}, the output will be considered correct.

Solution in C++14 (GCC 5.4.1) (judge verdict: Wrong Answer)

#include<bits/stdc++.h>

using namespace std;

int main(void) {
    long n;
    cin >> n;
    
    constexpr double eps = 1e-8;

    using P = pair<double,double>;

    vector<P> xy(n);
    for(auto &t: xy) cin >> t.first >> t.second;

    auto dis = [&] (P &p1, P &p2) {
        return sqrt(pow(p1.first - p2.first, 2) + pow(p1.second - p2.second, 2));
    };
    
    double r = 1e9;

    for(int i=0; i<n; i++)
        for(int j=i+1; j<n; j++)
            for(int k=j+1; k<n; k++) {
                P pa = xy[i], pb = xy[j], pc = xy[k];
                double a = dis(pb, pc), b = dis(pc, pa), c = dis(pa, pb);

                P pu = {
                    (a*a)*(b*b+c*c-a*a)*pa.first + (b*b)*(c*c+a*a-b*b)*pb.first + (c*c)*(a*a+b*b-c*c)*pc.first / ((a*a)*(b*b+c*c-a*a) + (b*b)*(c*c+a*a-b*b) + (c*c)*(a*a+b*b-c*c)),
                    (a*a)*(b*b+c*c-a*a)*pa.second + (b*b)*(c*c+a*a-b*b)*pb.second + (c*c)*(a*a+b*b-c*c)*pc.second / ((a*a)*(b*b+c*c-a*a) + (b*b)*(c*c+a*a-b*b) + (c*c)*(a*a+b*b-c*c)),
                };

                double d = dis(pa, pu);

                for(int l=0; l<n; l++) {
                    if(dis(xy[l], pu) > d+eps)
                        goto bad;
                }

                r = min(d, r);
bad:
                continue;
            }

    for(int i=0; i<n; i++)
        for(int j=i+1; j<n; j++) {
            P pa = xy[i], pb = xy[j];
            P pu = {
                (pa.first + pb.first)/2,
                (pa.second + pb.second)/2,
            };

            double d = dis(pa, pu);

            for(int l=0; l<n; l++) {
                if(dis(xy[l], pu) > d+eps)
                    goto bad2;
            }

            r = min(d, r);
bad2:
            continue;
        }

    cout << setprecision(16) << r << endl;

}