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: Accepted)

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define For(i,n,k) for(ll i=(n);i<(k);i++)
#define ALL(a)  (a).begin(),(a).end()
ll ans=0;
random_device rnd;
double dist(double x,double y,double a,double b){
    return sqrt((x-a)*(x-a)+(y-b)*(y-b));
}
void Main(){
    ll n;cin>>n;
    vector<double> x(n),y(n);
    For(i,0,n) cin>>x[i]>>y[i];
    double xmin=10000,xmax=-10000,ymin=10000,ymax=-10000;
    For(i,0,n){
        xmin=min(xmin,x[i]);
        xmax=max(xmax,x[i]);
        ymin=min(ymin,y[i]);
        ymax=max(ymax,y[i]);
    }
    double xdist=(xmax-xmin)/400,ydist=(ymax-ymin)/400;
    vector<pair<double,pair<double,double>>> plot;
    For(i,0,400){
        For(j,0,400){
            double X=xmin+i*xdist;
            double Y=ymin+j*ydist;
            double R=0;
            For(k,0,n){
                R=max(R,dist(X,Y,x[k],y[k]));
            }
            plot.push_back(make_pair(R,make_pair(X,Y)));
        }
    }
    sort(ALL(plot));
    int count=0;
    random_device seed_gen;
    mt19937 engine(seed_gen());
    uniform_real_distribution<> dist1(-0.001, 0.001);
    uniform_real_distribution<> dist2(-0.001, 0.001);
    count=0;
    while(true){
        count++;
        double X=0,Y=0;
        For(i,0,1){
            X+=plot[i].second.first;
            Y+=plot[i].second.second;
        }
        X+=dist1(engine);
        Y+=dist2(engine);
        double R=0;
        For(k,0,n){
            R=max(R,dist(X,Y,x[k],y[k]));
        }
        double D=plot[0].first-R;
        if(D>0) plot[0]=make_pair(R,make_pair(X,Y));
        if(count>4000000) break;
    }
    cout<<fixed<<setprecision(12)<<plot[0].first<<endl;
}
int main(){
    Main();
    return 0;
}