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<iostream>
#include<complex>
#include<cstdio>
#define EQ(x,y) (fabs((x)-(y))<EPS)
using namespace std;
typedef complex<double> Point;
const double EPS = 1e-8;
const int BUF = 55;
const int INF = 1 << 30;


class Segment{
public:
  Point bgn, end;

  Segment(){}
  Segment(Point b, Point e): bgn(b),  end(e){}
};

class Circle{
public:
  Point c;
  double r;
  
  Circle(){}
  Circle(Point c, double r): c(c), r(r){}
};

double cross(Point a, Point b){
  return imag(conj(a)*b);
}

Point rotate(Point p){
  return Point(-p.imag(),p.real());
}

Point calcIntersect(Segment a, Segment b){
  Point d1 = Point(a.end-a.bgn), d2 = Point(b.end-b.bgn);
  
  return a.bgn + d1*cross(b.bgn-a.bgn,d2)/cross(d1,d2);
}

Circle calcCircle(Point p1, Point p2, Point p3){
  Point mid1 = (p1+p2)/2.0;
  Point mid2 = (p1+p3)/2.0;
  Segment s1 = Segment(mid1,mid1+rotate(p2-p1));
  Segment s2 = Segment(mid2,mid2+rotate(p3-p1));
  
  Point center = calcIntersect(s1,s2);
  
  return Circle(center,abs(p1-center));
}

bool isOnline(Segment a, Segment b){
  return EQ(cross(a.end-a.bgn,b.end-a.bgn),0);
}


int nPt;
Point pt[BUF];

void read() {
    cin >> nPt;
    for (int i = 0; i < nPt; ++i) {
        int x, y;
        cin >> x >> y;
        pt[i] = Point(x, y);
    }
}


void work() {
    if (nPt == 2) {
        printf("%.12lf\n", abs(pt[0] - pt[1]) / 2);
        return;
    }
    
    double minV = INF;
    
    for (int i = 0; i < nPt; ++i) {
        for (int j = i + 1; j < nPt; ++j) {
            for (int k = j + 1; k < nPt; ++k) {
                Point center;
                
                if (isOnline(Segment(pt[i], pt[j]), Segment(pt[i], pt[k]))) {
                    center = (pt[i] + pt[j]) / 2.0;
                } else {
                    Circle circle = calcCircle(pt[i], pt[j], pt[k]);
                    center = circle.c;
                }
                
                double maxV = 0;
                for (int l = 0; l < nPt; ++l) {
                    maxV = max(maxV, norm(center - pt[l]));
                }

                minV = min(minV, maxV);
            }
        }
    }
    
    printf("%.12lf\n", sqrt(minV));
}


int main() {
    read();
    work();
    return 0;
}