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 points = (0..n)
        .map(|_| (sc.read::<f64>(), sc.read::<f64>()))
        .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).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 (x1, y1) = points[i];
                let (x2, y2) = points[j];
                let (x3, y3) = points[k];

                let a2 = (x2 - x3) * (x2 - x3) + (y2 - y3) * (y2 - y3);
                let b2 = (x1 - x3) * (x1 - x3) + (y1 - y3) * (y1 - y3);
                let c2 = (x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1);

                let area = ((x2 - x1) * (y3 - y1) - (x3 - x1) * (y2 - y1)) / 2.0;

                let px = (a2 * (b2 + c2 - a2) * x1
                    + b2 * (c2 + a2 - b2) * x2
                    + c2 * (a2 + b2 - c2) * x3)
                    / (16.0 * area * area);
                let py = (a2 * (b2 + c2 - a2) * y1
                    + b2 * (c2 + a2 - b2) * y2
                    + c2 * (a2 + b2 - c2) * y3)
                    / (16.0 * area * area);
                let rr = (x1 - px).powi(2) + (y1 - py).powi(2);

                let ok = points.iter().all(|&(x, y)| {
                    let dx = x - px;
                    let dy = y - py;
                    dx * dx + dy * dy <= rr
                });
                if ok {
                    let r = rr.sqrt();
                    if 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) / 2.0;
            let py = (y1 + y2) / 2.0;
            let r = ((x1 - x2).powi(2) + (y1 - y2).powi(2)).sqrt() / 2.0;
            let rr = r * r;

            let ok = points.iter().all(|&(x, y)| {
                let dx = x - px;
                let dy = y - py;
                dx * dx + dy * dy <= rr
            });
            if ok {
                let r = rr.sqrt();
                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()
    }
}