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 Rust (1.15.1) (judge verdict: Wrong Answer)

fn main() {
    let (r, w) = (std::io::stdin(), std::io::stdout());
    let mut sc = IO::new(r.lock(), w.lock());

    let n: usize = sc.read();
    let mut points = vec![];
    for _ in 0..n {
        let x: i64 = sc.read();
        let y: i64 = sc.read();
        points.push((x, y));
    }

    let mut ans = 1e15;
    for i in 0..n {
        for j in 0..i {
            for k in 0..j {
                let (xa, ya) = points[i];
                let (xb, yb) = points[j];
                let (xc, yc) = points[k];

                let a = (xb - xc) * (xb - xc);
                let b = (xc - xa) * (xc - xa);
                let c = (xa - xb) * (xa - xb);

                let aa = a * a;
                let bb = b * b;
                let cc = c * c;
                let ss16 = aa * (bb + cc - aa) + bb * (cc + aa - bb) + cc * (aa + bb - cc);
                if ss16 == 0 {
                    continue;
                }

                let ex =
                    aa * (bb + cc - aa) * xa + bb * (cc + aa - bb) * xb + cc * (aa + bb - cc) * xc;
                let ey =
                    aa * (bb + cc - aa) * ya + bb * (cc + aa - bb) * yb + cc * (aa + bb - cc) * yc;

                let px = (ex as f64) / (ss16 as f64);
                let py = (ey as f64) / (ss16 as f64);

                let ru = a * b * c;
                let rb = (a + b + c) * (-a + b + c) * (a - b + c) * (a + b - c);
                let r = (ru as f64) / (rb as f64).sqrt();

                let ok = points.iter().all(|&(x, y)| {
                    let x = x as f64;
                    let y = y as f64;
                    let dx = x - px;
                    let dy = y - py;
                    let d = (dx * dx + dy * dy).sqrt();
                    d <= r
                });

                if ok && ans > r {
                    ans = r;
                }
            }
        }
    }

    for i in 0..n {
        for j in 0..i {
            let (x1, y1) = points[i];
            let (x2, y2) = points[j];
            let px = ((x1 + x2) as f64) / 2.0;
            let py = ((y1 + y2) as f64) / 2.0;
            let dx = x1 - x2;
            let dy = y1 - y2;
            let d = dx * dx + dy * dy;
            let r = (d as f64).sqrt() / 2.0;
            let ok = points.iter().all(|&(x, y)| {
                let x = x as f64;
                let y = y as f64;
                let dx = x - px;
                let dy = y - py;
                let d = (dx * dx + dy * dy).sqrt();
                d <= r
            });

            if ok && ans > r {
                ans = r;
            }
        }
    }

    println!("{}", ans);
}

pub struct IO<R, W: std::io::Write>(R, std::io::BufWriter<W>);

impl<R: std::io::Read, W: std::io::Write> IO<R, W> {
    pub fn new(r: R, w: W) -> IO<R, W> {
        IO(r, std::io::BufWriter::new(w))
    }
    pub fn write<S: std::ops::Deref<Target = str>>(&mut self, s: S) {
        use std::io::Write;
        self.1.write(s.as_bytes()).unwrap();
    }
    pub fn read<T: std::str::FromStr>(&mut self) -> T {
        use std::io::Read;
        let buf = self
            .0
            .by_ref()
            .bytes()
            .map(|b| b.unwrap())
            .skip_while(|&b| b == b' ' || b == b'\n' || b == b'\r' || b == b'\t')
            .take_while(|&b| b != b' ' && b != b'\n' && b != b'\r' && b != b'\t')
            .collect::<Vec<_>>();
        unsafe { std::str::from_utf8_unchecked(&buf) }
            .parse()
            .ok()
            .expect("Parse error.")
    }
    pub fn vec<T: std::str::FromStr>(&mut self, n: usize) -> Vec<T> {
        (0..n).map(|_| self.read()).collect()
    }
    pub fn chars(&mut self) -> Vec<char> {
        self.read::<String>().chars().collect()
    }
}