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 Ruby (2.3.3) (judge verdict: Wrong Answer)

n = gets.chomp.to_i
x,y = n.times.map{gets.split.map(&:to_f)}.transpose

def get_circle_center_and_radius(x1, y1, x2, y2, x3, y3)
  d = 2 * ((y1 - y3) * (x1 - x2) - (y1 - y2) * (x1 - x3))
  return nil if d == 0
  x = ((y1 - y3) * (y1 ** 2 - y2 ** 2 + x1 ** 2 - x2 ** 2) - (y1 - y2) * (y1 ** 2 - y3 ** 2 + x1 ** 2 - x3 ** 2)) / d
  y = ((x1 - x3) * (x1 ** 2 - x2 ** 2 + y1 ** 2 - y2 ** 2) - (x1 - x2) * (x1 ** 2 - x3 ** 2 + y1 ** 2 - y3 ** 2)) / -d
  r2 = (x - x1) ** 2 + (y - y1) ** 2
  r = Math.sqrt(r2)
  return x,y,r,r2
end

def in?(cx, cy, rad, rad2, x,y,n)
  n.times do |i|
    if rad2 - (cx - x[i]) ** 2 + (cy - y[i]) ** 2 <= 0 # -0.0000001
      return false
    end
  end
  true
end

def get2(x1,y1, x2,y2)
  x = (x1+x2)/2
  y = (y1+y2)/2
  r2 = ((x1-x2) ** 2 + (y1-y2) ** 2)/4
  r = Math.sqrt(r2)
  return x,y,r,r2
end

if n <= 2
  cx,cy,r,r2 = get2(x[0],y[0], x[1],y[1])
  puts r
  exit
end

#puts solve(x[i],y[i], x[j],y[j], x[k],y[k])
ans = Float::INFINITY
n.times do |i|
  (i+1).upto(n-1).each do |j|
    (j+1).upto(n-1).each do |k|
      # p [x[i],x[j],x[k], y[i],y[j],y[k]]
      #      puts solved = solve(x[i],x[j],x[k], y[i],y[j],y[k])
      solved = get_circle_center_and_radius(x[i],y[i], x[j],y[j], x[k],y[k])
      next if solved.nil?
      cx, cy, rad, rad2 = solved
      if in?(cx, cy, rad, rad2, x,y,n)
        ans = rad if ans > rad
      end
    end
  end
end
puts ans