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 Python (3.4.3) (judge verdict: Runtime Error)

#!/usr/bin/env python3

import itertools
import math


EPS = 1e-6


def dot(a, b):
    return a.real * b.real + a.imag * b.imag


def cos_angle(a, b):
    x = dot(a, b) / abs(a) / abs(b)
    x = min(1, x)
    x = max(-1, x)
    return x


def enclose_triangle(p1, p2, p3):
    v12 = p2 - p1
    v23 = p3 - p2
    v31 = p1 - p3
    an1 = cos_angle(v12, -v31)
    an2 = cos_angle(-v12, v23)
    an3 = cos_angle(-v23, v31)
    if an1 < 0 + EPS or an2 < 0 + EPS or an3 < 0 + EPS:
        vx = max(v12, v23, v31, key=abs)
        rad = abs(vx) / 2
        if vx == v12:
            cent = (p1 + p2) / 2
        elif vx == v23:
            cent = (p2 + p3) / 2
        else:
            cent = (p3 + p1) / 2
    else:
        try:
            a = p1
            b = p2
            c = p3
            a2 = abs(v23) ** 2
            b2 = abs(v31) ** 2
            c2 = abs(v12) ** 2
            u = a2 * (b2 + c2 - a2) * a + b2 * (c2 + a2 - b2) * \
                b + c2 * (a2 + b2 - c2) * c
            u /= a2 * (b2 + c2 - a2) + b2 * \
                (c2 + a2 - b2) + c2 * (a2 + b2 - c2)
            rad = abs(u - p1)
            cent = u
        except Exception:
            print("DAME DESU!")
    return rad, cent


def enclose_points(n, ps):
    assert n >= 2
    if n == 2:
        return abs(ps[1] - ps[0]) / 2
    for p1, p2, p3 in itertools.combinations(ps, 3):
        rad_cand, cent_cand = enclose_triangle(p1, p2, p3)
        for q1 in ps:
            dist = abs(cent_cand - q1)
            if dist > rad_cand:
                break
        else:
            return rad_cand


def main():
    n = int(input())
    ps = []
    for _ in range(n):
        x, y = (float(z) for z in input().split())
        ps.append(complex(x, y))
    res = enclose_points(n, ps)
    print("{:.16f}".format(res))


if __name__ == "__main__":
    main()