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 Go (1.6) (judge verdict: Wrong Answer)

package main

import (
	"math"
	"fmt"
	"bufio"
	"os"
	"strconv"
)

//=====I/O=====

var (
	sc = bufio.NewScanner(os.Stdin)
	wr = bufio.NewWriter(os.Stdout)
)

func scanInt() int {
	sc.Scan()
	a,_ := strconv.Atoi(sc.Text())
	return a
}

func scanInt64() int64 {
	sc.Scan()
	a,_ := strconv.ParseInt(sc.Text(),10,64)
	return a
}

func scanFloat64() float64 {
	sc.Scan()
	a,_ := strconv.Atoi(sc.Text())
	return float64(a)
}

func scanInts(n int) []int {
	res := make([]int, n)
	for i := 0; i < n; i++ { res[i] = scanInt() }
	return res
}

func scanText() string {
	sc.Scan()
	return sc.Text()
}

func printInts(a ...int) {
	for i, e := range a {
		fmt.Fprint(wr, e)
		if i != len(a)-1 { fmt.Fprint(wr, " ") }
	}
	fmt.Fprintln(wr)
	wr.Flush()
}

//•*¨*•.¸¸♪func•*¨*•.¸¸♪

func dist(x1,y1,x2,y2 float64) float64 {
	return math.Sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2))
}

func findp(r,x1,y1,x2,y2 float64) (float64,float64,float64,float64) {
	d := dist(x1,y1,x2,y2)

	a := math.Atan2(y2-y1,x2-x1)
	theta := math.Acos(d/2.0/r)

	return r*math.Cos(a+theta), r*math.Sin(a+theta),r*math.Cos(a-theta), r*math.Sin(a-theta)
}

//•*¨*•.¸¸♪main•*¨*•.¸¸♪

func main() {
	sc.Split(bufio.ScanWords)
	// sc.Buffer(make([]byte, 10000), 100000000)

	n := scanInt()
	
	x := make([]float64, n)
	y := make([]float64, n)

	for i := 0; i < n; i++ {
		x[i], y[i] = scanFloat64(), scanFloat64()
	}

	l,r := float64(0), float64(1000000)

	for i := 0; i < 100; i++ {
		mid := (r+l)/2.0
		px := make([]float64, 0)
		py := make([]float64, 0)
		for j := 0; j < n; j++ {
			for k := j+1; k < n; k++ {
				if dist(x[j],y[j],x[k],y[k])/2.0 > mid {
					continue
				}
				x1,y1,x2,y2 := findp(mid,x[j],y[j],x[k],y[k])
				px = append(px,x1,x2)
				py = append(py,y1,y2)
			}
		}

		f := false
		num := len(px)

		for j := 0; j < num; j++ {
			ch := true
			for k := 0; k < n; k++ {
				if dist(px[j],py[j],x[k],y[k]) > mid+0.0000000001 {
					ch = false
					break
				}
			}
			if ch {
				f = true
			}
		}

		if f {
			r = mid
		} else {
			l = mid
		}
		// fmt.Println(f,num,mid,px)
	}

	fmt.Println((r+l)/2.0)

}