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>
#define repi(i,a,b) for(int i=(int)(a);i<(int)(b);++i)
#define rrepi(i,a,b) for(int i=((int)(b)-1);i>=(a);--i)
#define rep(i,n) repi(i,0,n)
#define rrep(i,n) rrepi(i,0,n)
#define debug(var)  do{std::cout << #var << " : "; view(var);}while(0)
using namespace std;
typedef long long ll;
template<typename T> void view(const std::vector<T>& v){for(const auto& e : v){ std::cout << e << " "; } std::cout << std::endl;}
template<typename T> void view(const std::vector<std::vector<T> >& vv){for(const auto& v : vv){ view(v); } }
template<typename T> void view(T e){std::cout << e << std::endl;}
template<typename T> void viewarr(T arr[], int n) { for(int i = 0; i < n; ++i) std::cout << arr[i] << " "; std::cout << std::endl; }
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
const int INF = 1e9;

const int MAX_N = 50;
double x[MAX_N];
double y[MAX_N];

template<typename T> T pow2(T a) {
    return a*a;
}

int main() {
    int N;
    double ans = INF;
    cin >> N;
    rep(i,N) cin >> x[i] >> y[i];
    rep(i,N) rep(j,N) rep(k,N) {
        double cx, cy;
        cx = (x[i] + x[j] + x[k])/3;
        cy = (y[i] + y[j] + y[k])/3;
        double r = sqrt(pow2(cx-x[i]) + pow2(cy-y[i]));
        bool ok = true;
        rep(l,N) {
            double d = sqrt(pow2(cx-x[l]) + pow2(cy-y[l]));
            if(r < d) {
                ok = false;
                break;
            }
        }
        if(ok) chmin(ans, r);
    }
    rep(i,N) rep(j,N) {
        double cx, cy;
        cx = (x[i] + x[j])/2;
        cy = (y[i] + y[j])/2;
        double r = sqrt(pow2(cx-x[i]) + pow2(cy-y[i]));
        bool ok = true;
        rep(k,N) {
            double d = sqrt(pow2(cx-x[k]) + pow2(cy-y[k]));
            if(r < d) {
                ok = false;
                break;
            }
        }
        if(ok) chmin(ans, r);
    }
    printf("%.8lf\n", ans);
    return 0;
}