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 PyPy3 (2.4.0) (judge verdict: Wrong Answer)

n=int(input())

def bai(x):
    return int(x)*2.0

xy=[list(map(bai, input().split())) for _ in range(n)]

#nは50だから4重ループでも間に合う？
#2500*2500

if n==2:
    print((((xy[0][0]-xy[1][0])**2 +(xy[0][1]-xy[1][1])**2) **0.5)*0.5)
    exit()

ans=10**9

def gaishin(a,b,c,d,e,f):
    if (a-c)*(d-f)==(c-e)*(b-d):
        y=(max([b,d,f])-min([b,d,f]))/2.0+min([b,d,f])
        x=(max([a,c,e])-min([a,c,e]))/2.0+min([a,c,e])

        #print(a,b,c,d,e,f,"==>",x,y)

    else:
        y=1.0*((e-a)*(a**2+b**2-c**2-d**2)-(c-a)*(a**2+b**2-e**2-f**2))/(2.0*(e-a)*(b-d)-2.0*(c-a)*(b-f))
        if e-a!=0:
            x=(2.0*(b-f)*y-a**2-b**2+e**2+f**2)/(2.0*(e-a))
        elif c-a!=0:
            x=(2.0*(b-d)*y-a**2-b**2+c**2+d**2)/(2.0*(c-a))
        else:
            print(a,b,c,d,e,f)
            exit()

    return x,y

xy.sort()

for i in range(n-2):
    for j in range(i+1,n-1):
        for k in range(i+2,n):
            #print(xy[i],xy[j],xy[k])

            gx,gy=gaishin(xy[i][0],xy[i][1],xy[j][0],xy[j][1],xy[k][0],xy[k][1])
            d=((1.0*(gx-xy[i][0]))**2+(1.0*(gy-xy[i][1]))**2)
            flag=0
            #print(gx,gy)
            for (x,y) in xy:
                if (x,y) != xy[i] and (x,y) != xy[j] and (x,y) != xy[k]:
                    if ((1.0*(gx-x))**2+(1.0*(gy-y))**2) >d:
                        flag=1
                        #print(((1.0*(gx-x))**2+(1.0*(gy-y))**2)**0.5,"-",d,"=",((1.0*(gx-x))**2+(1.0*(gy-y))**2)**0.5-d) 
                        break
            if flag==0:
                ans=min(ans,d**0.5)
                #print(">>>>",xy[i],xy[j],xy[k],d**0.5,gx,gy)

print(ans/2)