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 Scala (2.11.7) (judge verdict: Wrong Answer)

import java.io._
import java.util.StringTokenizer
import scala.util.control.Breaks.{breakable,break}
import scala.collection.mutable.{Map, Stack, Queue, PriorityQueue, Set}

case class Coord(x: Double, y: Double) extends Ordered[Coord] {

  def this(p: (Double, Double)) = this(p._1, p._2)

  def compare(that: Coord): Int = {
    if (this.x != that.x)
      this.x.compare(that.x)
    else
      this.y.compare(that.y)
  }

  def +(co: Coord): Coord = {
    Coord(this.x + co.x, this.y + co.y)
  }

  def -(co: Coord): Coord = {
    Coord(this.x - co.x, this.y - co.y)
  }

  def toPair: (Double, Double) = (x, y)

  def dist(that: Coord): Double = {
    import Math.{sqrt, pow}
    sqrt(pow(this.x - that.x, 2) + pow(this.y - that.y, 2))
  }

  def moveTo(that: Coord, ratio: Double): Coord = {
    import Math.{sqrt, pow, abs}
    val dx = abs(x - that.x) * ratio
    val dy = abs(y - that.y) * ratio

    val gx =
      if (x > that.x) x - dx
      else x + dx
    val gy =
      if (y > that.y) y - dy
      else y + dy

    Coord(gx, gy)
  }

}

object Main extends App {
  val in = new InputReader(System.in)
  val pw = new PrintWriter(System.out)

  val N = in.next().toInt
  val p = new Array[Coord](N)
  for (i <- 0 until N) {
    val x, y = in.next().toInt
    p(i) = Coord(x, y)
  }

  //
  var now = Coord(0.0, 0.0)
  for (n <- 1 to 300000) {
    var hoge: Coord = null
    var maxDist = 0.0
    for (c <- p) {
      if (now.dist(c) > maxDist) {
        maxDist = now.dist(c)
        hoge = c
      }
    }

    now = now.moveTo(hoge, 1.0 / n)
  }

  var maxDist = 0.0
  for (c <- p) {
    if (now.dist(c) > maxDist) {
      maxDist = now.dist(c)
    }
  }

  println(maxDist)
}

object Sub {
  def print2DimArray[A](mat: Array[Array[A]]): Unit = {
    mat.foreach(lin => println(lin.deep))
  }
}

class InputReader(stream: InputStream) {
  private[this] val reader = new BufferedReader(new InputStreamReader(stream))
  private[this] var tokenizer: StringTokenizer = new StringTokenizer(reader.readLine())
  def next(): String = {
    while (!tokenizer.hasMoreTokens()) {
      tokenizer = new StringTokenizer(reader.readLine())
    }
    tokenizer.nextToken()
  }
}