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)

use std::cmp;

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 points = (0..n)
        .map(|_| (sc.read::<i64>(), sc.read::<i64>()))
        .collect::<Vec<_>>();

    //    let points = points
    //        .into_iter()
    //        .map(|(x, y)| Point { x: x, y: y })
    //        .collect::<Vec<_>>();
    //    let hull = extract_convex_hull(&points, true);
    //    let points = hull
    //        .into_iter()
    //        .map(|i| (points[i].x, points[i].y))
    //        .collect::<Vec<_>>();
    //
    //    let n = points.len();

    if n == 2 {
        let (x1, y1) = points[0];
        let (x2, y2) = points[1];
        let dx = x1 - x2;
        let dy = y1 - y2;
        let r = ((dx * dx + dy * dy) as f64).sqrt() / 2.0;
        println!("{}", r);
        return;
    }

    let mut ans = 1e15;
    for i in 0..n {
        for j in 0..i {
            for k in 0..j {
                let (a, b) = points[i];
                let (c, d) = points[j];
                let (e, f) = points[k];
                if e == a && c == a {
                    let px = a as f64;
                    let max_y = cmp::max(cmp::max(b, d), f) as f64;
                    let min_y = cmp::min(cmp::min(b, d), f) as f64;
                    let py = (max_y + min_y) / 2.0;
                    let r = (max_y - min_y) / 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;
                        dx * dx + dy * dy <= r * r
                    });
                    if ok {
                        if ans > r {
                            ans = r;
                        }
                    }

                    continue;
                }
                let a = a as f64;
                let b = b as f64;
                let c = c as f64;
                let d = d as f64;
                let e = e as f64;
                let f = f as f64;

                let aa = a * a;
                let bb = b * b;
                let cc = c * c;
                let dd = d * d;
                let ee = e * e;
                let ff = f * f;

                let div_y = (e - a) * (b - d) - (c - a) * (b - f);
                let top_y = (e - a) * (aa + bb - cc - dd) - (c - a) * (aa + bb - ee - ff);
                let py = top_y / 2.0 / div_y;
                let px = if c == a {
                    let t = 2.0 * (b - f) * py - aa - bb + ee + ff;
                    t / 2.0 / (e - a)
                } else {
                    let t = 2.0 * (b - d) * py - aa - bb + cc + dd;
                    t / 2.0 / (c - a)
                };
                let rr = (px - a) * (px - a) + (py - b) * (py - b);
                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;
                    dx * dx + dy * dy <= rr
                });
                if ok {
                    let r = rr.sqrt();
                    //                    eprintln!("r={} ijk={:?} o={:?}", r, (i, j, k), (px, py));
                    if ans > r {
                        ans = r;
                    }
                }
            }
        }
    }

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

pub fn extract_convex_hull(points: &Vec<Point>, contain_on_segment: bool) -> Vec<usize> {
    let n = points.len();
    if n <= 1 {
        return vec![0];
    }

    let mut ps: Vec<usize> = (0..n).collect();
    ps.sort_by(|&a, &b| {
        if points[a].x == points[b].x {
            points[a].y.partial_cmp(&points[b].y).unwrap()
        } else {
            points[a].x.partial_cmp(&points[b].x).unwrap()
        }
    });

    let mut qs: Vec<usize> = Vec::new();
    for &i in &ps {
        while qs.len() > 1 {
            let k = qs.len();
            let det = (points[qs[k - 1]] - points[qs[k - 2]]).det(&(points[i] - points[qs[k - 1]]));
            if det < 0.0 || (det <= 0.0 && !contain_on_segment) {
                qs.pop();
            } else {
                break;
            }
        }
        qs.push(i);
    }

    let t = qs.len();
    for i in (0..(n - 1)).rev() {
        let i = ps[i];
        while qs.len() > t {
            let k = qs.len();
            let det = (points[qs[k - 1]] - points[qs[k - 2]]).det(&(points[i] - points[qs[k - 1]]));
            if det < 0.0 || (det <= 0.0 && !contain_on_segment) {
                qs.pop();
            } else {
                break;
            }
        }
        qs.push(i);
    }

    qs.pop();
    return qs;
}

#[derive(Debug, Copy, Clone)]
pub struct Point {
    x: f64,
    y: f64,
}

impl std::ops::Sub for Point {
    type Output = Point;
    fn sub(self, other: Point) -> Point {
        Point {
            x: self.x - other.x,
            y: self.y - other.y,
        }
    }
}

impl Point {
    pub fn det(&self, other: &Point) -> f64 {
        self.x * other.y - self.y * other.x
    }
}

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()
    }
}