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;
#define rep(i,n) for(int i=0;i<(n);i++)
#define rep1(i,n) for(int i=1;i<=(n);i++)
#define all(x) (x).begin(),(x).end()
#define V vector
typedef V<int> vi;
typedef V<vi> vvi;
typedef long long ll;
typedef pair<int, int> P;
typedef tuple<int, int, int> T;
constexpr auto INF = INT_MAX >> 1;
constexpr auto LINF = 5000000000000000;
constexpr auto MOD = 1000000007;

int n;
vi x, y;

double fx(double xx) {

	double yl = 0, yr = 1000;
	double re = 0;
	while (yr - yl > pow(10, -10)) {

		double c1 = (2 * yl + yr) / 3;
		double c2 = (2 * yr + yl) / 3;

		double r1 = 0, r2 = 0;
		rep(i, n)r1 = max(r1, sqrt(pow(x[i] - xx, 2) + pow(y[i] - c1, 2)));
		rep(i, n)r2 = max(r2, sqrt(pow(x[i] - xx, 2) + pow(y[i] - c2, 2)));
		re = (r1 + r2) / 2;
		if (r1 < r2)yr = c2;
		else yl = c1;
	}

	return re;

}

int main() {

	cin >> n;
	x.resize(n);
	y.resize(n);
	rep(i, n)cin >> x[i] >> y[i];

	double xl = 0, xr = 1000;
	while (xr - xl > pow(10, -10)) {

		double xc1 = (2 * xl + xr) / 3;
		double xc2 = (2 * xr + xl) / 3;

		if (fx(xc1) < fx(xc2))xr = xc2;
		else xl = xc1;
	}

	cout << fixed << setprecision(8);
	cout << fx(xl) << endl;

}