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 (Python):
import sys
input = sys.stdin.readline

def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))

def main():
    import cmath
    import itertools
    import math
    import sys


    sys.setrecursionlimit(10 ** 9)
    IINF = 10 ** 18
    MOD = 10 ** 9 + 7
    


    INF = float("inf")
    PI = cmath.pi
    TAU = cmath.pi * 2
    EPS = 1e-10


    class Point:
        """
        2次元空間上の点
        """

        
        CCW_COUNTER_CLOCKWISE = 1
        
        CCW_CLOCKWISE = -1
        
        CCW_ONLINE_BACK = 2
        
        CCW_ONLINE_FRONT = -2
        
        CCW_ON_SEGMENT = 0

        def __init__(self, x: float, y: float):
            self.c = complex(x, y)
            
        @property
        def x(self):
            return self.c.real

        @property
        def y(self):
            return self.c.imag

        @staticmethod
        def from_complex(c: complex):
            return Point(c.real, c.imag)

        @staticmethod
        def from_polar(r: float, phi: float):
            c = cmath.rect(r, phi)
            return Point(c.real, c.imag)

        def __add__(self, p):
            """
            :param Point p:
            """
            c = self.c + p.c
            return Point(c.real, c.imag)

        def __iadd__(self, p):
            """
            :param Point p:
            """
            self.c += p.c
            return self

        def __sub__(self, p):
            """
            :param Point p:
            """
            c = self.c - p.c
            return Point(c.real, c.imag)

        def __isub__(self, p):
            """
            :param Point p:
            """
            self.c -= p.c
            return self

        def __mul__(self, f: float):
            c = self.c * f
            return Point(c.real, c.imag)

        def __imul__(self, f: float):
            self.c *= f
            return self

        def __truediv__(self, f: float):
            c = self.c / f
            return Point(c.real, c.imag)

        def __itruediv__(self, f: float):
            self.c /= f
            return self

        def __repr__(self):
            return "({}, {})".format(round(self.x, 10), round(self.y, 10))

        def __neg__(self):
            c = -self.c
            return Point(c.real, c.imag)

        def __eq__(self, p):
            return abs(self.c - p.c) < EPS

        def __abs__(self):
            return abs(self.c)

        @staticmethod
        def ccw(a, b, c):
            """
            線分 ab に対する c の位置
            線分上にあるか判定するだけなら on_segment とかのが速い
            :param Point a:
            :param Point b:
            :param Point c:
            """
            b = b - a
            c = c - a
            det = b.det(c)
            if det > EPS:
                return Point.CCW_COUNTER_CLOCKWISE
            if det < -EPS:
                return Point.CCW_CLOCKWISE
            if b.dot(c) < -EPS:
                return Point.CCW_ONLINE_BACK
            if c.norm() - b.norm() > EPS:
                return Point.CCW_ONLINE_FRONT
            return Point.CCW_ON_SEGMENT

        def dot(self, p):
            """
            内積
            :param Point p:
            :rtype: float
            """
            return self.x * p.x + self.y * p.y

        def det(self, p):
            """
            外積
            :param Point p:
            :rtype: float
            """
            return self.x * p.y - self.y * p.x

        def dist(self, p):
            """
            距離
            :param Point p:
            :rtype: float
            """
            return abs(self.c - p.c)

        def norm(self):
            """
            原点からの距離
            :rtype: float
            """
            return abs(self.c)

        def phase(self):
            """
            原点からの角度
            :rtype: float
            """
            return cmath.phase(self.c)

        def angle(self, p, q):
            """
            p に向いてる状態から q まで反時計回りに回転するときの角度
            -pi <= ret <= pi
            :param Point p:
            :param Point q:
            :rtype: float
            """
            return (cmath.phase(q.c - self.c) - cmath.phase(p.c - self.c) + PI) % TAU - PI

        def area(self, p, q):
            """
            p, q となす三角形の面積
            :param Point p:
            :param Point q:
            :rtype: float
            """
            return abs((p - self).det(q - self) / 2)

        def projection_point(self, p, q, allow_outer=False):
            """
            線分 pq を通る直線上に垂線をおろしたときの足の座標
            :param Point p:
            :param Point q:
            :param allow_outer: 答えが線分の間になくても OK
            :rtype: Point|None
            """
            diff_q = q - p
            
            r = (self - p).dot(diff_q) / abs(diff_q)
            
            phase = diff_q.phase()

            ret = Point.from_polar(r, phase) + p
            if allow_outer or (p - ret).dot(q - ret) < EPS:
                return ret
            return None

        def reflection_point(self, p, q):
            """
            直線 pq を挟んで反対にある点
            :param Point p:
            :param Point q:
            :rtype: Point
            """
            
            r = abs(self - p)
            
            angle = p.angle(q, self)
            
            angle = (q - p).phase() - angle
            return Point.from_polar(r, angle) + p

        def on_segment(self, p, q, allow_side=True):
            """
            点が線分 pq の上に乗っているか
            :param Point p:
            :param Point q:
            :param allow_side: 端っこでギリギリ触れているのを許容するか
            :rtype: bool
            """
            if not allow_side and (self == p or self == q):
                return False
            
            
            return abs((p - self).det(q - self)) < EPS and (p - self).dot(q - self) < EPS


    class Line:
        """
        2次元空間上の直線
        """

        def __init__(self, a: float, b: float, c: float):
            """
            直線 ax + by + c = 0
            """
            self.a = a
            self.b = b
            self.c = c

        @staticmethod
        def from_gradient(grad: float, intercept: float):
            """
            直線 y = ax + b
            :param grad: 傾き
            :param intercept: 切片
            :return:
            """
            return Line(grad, -1, intercept)

        @staticmethod
        def from_segment(p1, p2):
            """
            :param Point p1:
            :param Point p2:
            """
            a = p2.y - p1.y
            b = p1.x - p2.x
            c = p2.y * (p2.x - p1.x) - p2.x * (p2.y - p1.y)
            return Line(a, b, c)

        @property
        def gradient(self):
            """
            傾き
            """
            return INF if self.b == 0 else -self.a / self.b

        @property
        def intercept(self):
            """
            切片
            """
            return INF if self.b == 0 else -self.c / self.b

        def is_parallel_to(self, l):
            """
            平行かどうか
            :param Line l:
            """
            
            return abs(Point.from_rect(self.a, self.b).det(Point.from_rect(l.a, l.b))) < EPS

        def is_orthogonal_to(self, l):
            """
            直行しているかどうか
            :param Line l:
            """
            
            return abs(Point.from_rect(self.a, self.b).dot(Point.from_rect(l.a, l.b))) < EPS

        def intersection_point(self, l):
            """
            交差する点
            :param Line l:
            :rtype: Point|None
            """
            a1, b1, c1 = self.a, self.b, self.c
            a2, b2, c2 = l.a, l.b, l.c
            det = a1 * b2 - a2 * b1
            if abs(det) < EPS:
                
                return None
            x = (b1 * c2 - b2 * c1) / det
            y = (a2 * c1 - a1 * c2) / det
            return Point.from_rect(x, y)

        def dist(self, p):
            """
            他の点との最短距離
            :param Point p:
            """
            raise NotImplementedError()

        def has_point(self, p):
            """
            p が直線上に乗っているかどうか
            :param Point p:
            """
            return abs(self.a * p.x + self.b * p.y + self.c) < EPS


    class Segment:
        """
        2次元空間上の線分
        """

        def __init__(self, p1, p2):
            """
            :param Point p1:
            :param Point p2:
            """
            self.p1 = p1
            self.p2 = p2

        def norm(self):
            """
            線分の長さ
            """
            return abs(self.p1 - self.p2)

        def phase(self):
            """
            p1 を原点としたときの p2 の角度
            """
            return (self.p2 - self.p1).phase()

        def is_parallel_to(self, s):
            """
            平行かどうか
            :param Segment s:
            :return:
            """
            
            return abs((self.p1 - self.p2).det(s.p1 - s.p2)) < EPS

        def is_orthogonal_to(self, s):
            """
            直行しているかどうか
            :param Segment s:
            :return:
            """
            
            return abs((self.p1 - self.p2).dot(s.p1 - s.p2)) < EPS

        def intersects_with(self, s, allow_side=True):
            """
            交差するかどうか
            :param Segment s:
            :param allow_side: 端っこでギリギリ触れているのを許容するか
            """
            if self.is_parallel_to(s):
                
                return (s.p1.on_segment(self.p1, self.p2, allow_side) or
                        s.p2.on_segment(self.p1, self.p2, allow_side) or
                        self.p1.on_segment(s.p1, s.p2, allow_side) or
                        self.p2.on_segment(s.p1, s.p2, allow_side))
            else:
                
                det_upper = EPS if allow_side else -EPS
                ok = True
                
                ok &= (self.p2 - self.p1).det(s.p1 - self.p1) * (self.p2 - self.p1).det(s.p2 - self.p1) < det_upper
                
                ok &= (s.p2 - s.p1).det(self.p1 - s.p1) * (s.p2 - s.p1).det(self.p2 - s.p1) < det_upper
                return ok

        def closest_point(self, p):
            """
            線分上の、p に最も近い点
            :param Point p:
            """
            
            d = (p - self.p1).dot(self.p2 - self.p1) / self.norm()
            
            if d < EPS:
                return self.p1
            
            if -EPS < d - self.norm():
                return self.p2
            
            return Point.from_polar(d, (self.p2 - self.p1).phase()) + self.p1

        def dist(self, p):
            """
            他の点との最短距離
            :param Point p:
            """
            return abs(p - self.closest_point(p))

        def dist_segment(self, s):
            """
            他の線分との最短距離
            :param Segment s:
            """
            if self.intersects_with(s):
                return 0.0
            return min(
                self.dist(s.p1),
                self.dist(s.p2),
                s.dist(self.p1),
                s.dist(self.p2),
            )

        def has_point(self, p, allow_side=True):
            """
            p が線分上に乗っているかどうか
            :param Point p:
            :param allow_side: 端っこでギリギリ触れているのを許容するか
            """
            return p.on_segment(self.p1, self.p2, allow_side=allow_side)




    class Circle:
        def __init__(self, o, r):
            """
            :param Point o:
            :param float r:
            """
            self.o = o
            self.r = r

        def __eq__(self, other):
            return self.o == other.o and abs(self.r - other.r) < EPS

        def ctc(self, c):
            """
            共通接線 common tangent の数
            4: 離れてる
            3: 外接
            2: 交わってる
            1: 内接
            0: 内包
            inf: 同一
            :param Circle c:
            :rtype: int
            """
            if self.o == c.o:
                return INF if abs(self.r - c.r) < EPS else 0
            
            d = self.o.dist(c.o) - self.r - c.r
            if d > EPS:
                return 4
            elif d > -EPS:
                return 3
            
            elif d + min(self.r, c.r) * 2 > EPS:
                return 2
            elif d + min(self.r, c.r) * 2 > -EPS:
                return 1
            return 0

        def has_point_on_edge(self, p):
            """
            指定した点が円周上にあるか
            :param Point p:
            :rtype: bool
            """
            return abs(self.o.dist(p) - self.r) < EPS

        def contains(self, p, allow_on_edge=True):
            """
            指定した点を含むか
            :param Point p:
            :param bool allow_on_edge: 辺上の点を許容するか
            """
            if allow_on_edge:
                
                return self.o.dist(p) - self.r < EPS
            else:
                
                return self.o.dist(p) - self.r < -EPS

        def area(self):
            """
            面積
            """
            return self.r ** 2 * PI

        def circular_segment_area(self, angle):
            """
            弓形⌓の面積
            :param float angle: 角度ラジアン
            """
            
            sector_area = self.area() * angle / TAU
            
            return sector_area - self.r ** 2 * math.sin(angle) / 2

        def intersection_points(self, other, allow_outer=False):
            """
            :param Segment|Circle other:
            :param bool allow_outer:
            """
            if isinstance(other, Segment):
                return self.intersection_points_with_segment(other, allow_outer=allow_outer)
            if isinstance(other, Circle):
                return self.intersection_points_with_circle(other)
            raise NotImplementedError()

        def intersection_points_with_segment(self, s, allow_outer=False):
            """
            線分と交差する点のリスト
            :param Segment s:
            :param bool allow_outer: 線分の間にない点を含む
            :rtype: list of Point
            """
            
            projection_point = self.o.projection_point(s.p1, s.p2, allow_outer=True)
            
            dist = self.o.dist(projection_point)
            
            if dist - self.r > EPS:
                return []
            if dist - self.r > -EPS:
                if allow_outer or s.has_point(projection_point):
                    return [projection_point]
                else:
                    return []
            
            diff = Point.from_polar(math.sqrt(self.r ** 2 - dist ** 2), s.phase())
            ret1 = projection_point + diff
            ret2 = projection_point - diff
            ret = []
            if allow_outer or s.has_point(ret1):
                ret.append(ret1)
            if allow_outer or s.has_point(ret2):
                ret.append(ret2)
            return ret

        def intersection_points_with_circle(self, other):
            """
            円と交差する点のリスト
            :param circle other:
            :rtype: list of Point
            """
            ctc = self.ctc(other)
            if not 1 <= ctc <= 3:
                return []
            if ctc == 3:
                
                return [Point.from_polar(self.r, (other.o - self.o).phase()) + self.o]
            if ctc == 1:
                
                if self.r > other.r:
                    return [Point.from_polar(self.r, (other.o - self.o).phase()) + self.o]
                else:
                    return [Point.from_polar(self.r, (self.o - other.o).phase()) + self.o]
            
            assert ctc == 2

            a = other.r
            b = self.r
            c = self.o.dist(other.o)
            
            cos_a = (b ** 2 + c ** 2 - a ** 2) / (2 * b * c)
            angle = math.acos(cos_a)
            phi = (other.o - self.o).phase()
            return [
                self.o + Point.from_polar(self.r, phi + angle),
                self.o + Point.from_polar(self.r, phi - angle),
            ]

        def tangent_points_with_point(self, p):
            """
            p を通る接線との接点
            :param Point p:
            :rtype: list of Point
            """
            dist = self.o.dist(p)
            
            if dist - self.r < -EPS:
                
                return []
            if dist - self.r < EPS:
                
                return [Point(p.x, p.y)]

            a = math.sqrt(dist ** 2 - self.r ** 2)
            b = self.r
            c = dist
            
            cos_a = (b ** 2 + c ** 2 - a ** 2) / (2 * b * c)
            angle = math.acos(cos_a)
            phi = (p - self.o).phase()
            return [
                self.o + Point.from_polar(self.r, phi + angle),
                self.o + Point.from_polar(self.r, phi - angle),
            ]

        def tangent_points_with_circle(self, other):
            """
            other との共通接線との接点
            :param Circle other:
            :rtype: list of Point
            """
            ctc = self.ctc(other)
            if ctc > 4:
                raise ValueError('2つの円が同一です')
            if ctc == 0:
                return []
            if ctc == 1:
                return self.intersection_points_with_circle(other)

            assert ctc in (2, 3, 4)
            ret = []
            
            
            if abs(self.r - other.r) < EPS:
                
                phi = (other.o - self.o).phase()
                ret.append(self.o + Point.from_polar(self.r, phi + PI / 2))
                ret.append(self.o + Point.from_polar(self.r, phi - PI / 2))
            else:
                
                intersection = self.o + (other.o - self.o) / (self.r - other.r) * self.r
                ret += self.tangent_points_with_point(intersection)

            
            
            intersection = self.o + (other.o - self.o) / (self.r + other.r) * self.r
            ret += self.tangent_points_with_point(intersection)
            return ret

        @staticmethod
        def circumscribed_of(p1, p2, p3):
            """
            p1・p2・p3 のなす三角形の外接円
            Verify:
            :param Point p1:
            :param Point p2:
            :param Point p3:
            """
            if p1.on_segment(p2, p3):
                return Circle((p2 + p3) / 2, p2.dist(p3) / 2)
            if p2.on_segment(p1, p3):
                return Circle((p1 + p3) / 2, p1.dist(p3) / 2)
            if p3.on_segment(p1, p2):
                return Circle((p1 + p2) / 2, p1.dist(p2) / 2)
            x1, x2, x3 = p1.x, p2.x, p3.x
            y1, y2, y3 = p1.y, p2.y, p3.y

            a = (y1 - y3) * (y1 ** 2 - y2 ** 2 + x1 ** 2 - x2 ** 2) - \
                (y1 - y2) * (y1 ** 2 - y3 ** 2 + x1 ** 2 - x3 ** 2)
            b = ((y1 - y3) * (x1 - x2) - (y1 - y2) * (x1 - x3)) * 2
            c = (x1 - x3) * (x1 ** 2 - x2 ** 2 + y1 ** 2 - y2 ** 2) - \
                (x1 - x2) * (x1 ** 2 - x3 ** 2 + y1 ** 2 - y3 ** 2)
            d = ((x1 - x3) * (y1 - y2) - (x1 - x2) * (y1 - y3)) * 2
            ox = a / b if abs(b) > EPS else 0
            oy = c / d if abs(d) > EPS else 0
            o = Point(ox, oy)
            return Circle(o, o.dist(p1))


    mod=10**9+7
    N=I()
    pL=[]
    for i in range(N):
        x,y=MI()
        pL.append(Point(x,y))
        
    ans=10**6
    
    for i in range(N):
        for j in range(i+1,N):
            cx=(pL[i].x + pL[j].x)/2
            cy=(pL[i].y + pL[j].y)/2
            
            c=Point(cx,cy)
            temp_r=0
            for k in range(N):
                p=pL[k]
                temp_r=max(p.dist(c),temp_r)
            ans=min(ans,temp_r)
            
    for i in range(N):
        for j in range(i+1,N):
            for k in range(j+1,N):
                p1=pL[i]
                p2=pL[j]
                p3=pL[k]
                circle=Circle.circumscribed_of(p1, p2, p3)
                flag=1
                for l in range(N):
                    p=pL[l]
                    if not circle.contains(p):
                        flag=0
                        break
                    
                if flag:
                    temp_r=circle.r
                    ans=min(ans,temp_r)
                    
                    
    print(ans)
            

main()

Solution (Python):
import math
n = int(input())
xy = [list(map(int,input().split())) for _ in range(n)]
point = []
r = 0
for i in range(n-1):
    x1,y1=xy[i]
    for j in range(i+1,n):
        x2,y2=xy[j]
        d = ((x1-x2)/2)**2+((y1-y2)/2)**2
        if r**2 > d:
            if y1-y2 != 0:
                a = -(x1-x2)/(y1-y2)
                x = math.sqrt((r**2-d)/(a**2+1))//10**(-6)*10**(-6)
                point.append([(x1+x2)/2+x,(y1+y2)/2+a*x])
                point.append([(x1+x2)/2-x,(y1+y2)/2-a*x])
            else:
                x = math.sqrt(r**2-d)//1//10**(-6)*10**(-6)
                point.append([(x1+x2)/2,(y1+y2)/2+x])
                point.append([(x1+x2)/2,(y1+y2)/2-x])
        elif r**2 == d:
            point.append([(x1+x2)/2,(y1+y2)/2])

r_o = 800
r_i = 0
while r_o-r_i > 10**(-8):
    judge = 0
    while point:
        x,y = point.pop()
        c = 0
        for i,j in xy:
            if (x-i)**2+(y-j)**2 > r**2:
                c = 1
                break
        if c == 0:
            judge = 1
            break
            
    if judge == 1:
        r_o = r
    else:
        r_i = r
    r = (r_o+r_i)/2
    point = []
    for i in range(n-1):
        x1,y1=xy[i]
        for j in range(i+1,n):
            x2,y2=xy[j]
            d = ((x1-x2)/2)**2+((y1-y2)/2)**2
            if r**2 > d:
                if y1-y2 != 0:
                    a = -(x1-x2)/(y1-y2)
                    x = math.sqrt((r**2-d)/(a**2+1))//10**(-6)*10**(-6)
                    point.append([(x1+x2)/2+x,(y1+y2)/2+a*x])
                    point.append([(x1+x2)/2-x,(y1+y2)/2-a*x])
                else:
                    x = math.sqrt(r**2-d)//10**(-6)*10**(-6)
                    point.append([(x1+x2)/2,(y1+y2)/2+x])
                    point.append([(x1+x2)/2,(y1+y2)/2-x])
            elif r**2 == d:
                point.append([(x1+x2)/2,(y1+y2)/2])
    
print(r)

Solution (Python):
import math
N=int(input())

def get_circle_2p(p1,p2):
  x1,y1=p1
  x2,y2=p2
  
  x=(x1+x2)/2
  y=(y1+y2)/2  
  r=math.sqrt((x1-x2)**2+(y1-y2)**2)/2
  return x,y,r

def get_circle_3p(p1,p2,p3):
  x1,y1=p1
  x2,y2=p2
  x3,y3=p3
  d=2*((y1-y3)*(x1-x2)-(y1-y2)*(x1-x3))  
  
  if d==0:
    rad1=math.sqrt((x1-x2)**2+(y1-y2)**2)/2
    rad2=math.sqrt((x1-x3)**2+(y1-y3)**2)/2
    rad3=math.sqrt((x2-x3)**2+(y2-y3)**2)/2
    
    if rad1>=rad2 and rad1>=rad3:
      x=(x1+x2)/2
      y=(y1+y2)/2
      return x,y,rad1
    elif rad2>=rad1 and rad2>=rad3:
      x=(x1+x3)/2
      y=(y1+y3)/2
      return x,y,rad2
    elif rad3>=rad1 and rad3>=rad2:
      x=(x2+x3)/2
      y=(y2+y3)/2
      return x,y,rad3      
  else:
    x=((y1-y3)*(y1**2-y2**2+x1**2-x2**2)-(y1-y2)*(y1**2-y3**2+x1**2-x3**2))/d
    y=((x1-x3)*(x1**2-x2**2+y1**2-y2**2)-(x1-x2)*(x1**2-x3**2+y1**2-y3**2))/-d
    r=math.sqrt((x-x1)**2+(y-y1)**2)
    return x,y,r
  
xylist=[]
for i in range(N):
  xi,yi=map(int,input().split())
  xylist.append((xi,yi))
  


if N==2:
  x,y,r=get_circle_2p(xylist[0],xylist[1])
  print(r)
else:
  min_radius=float("inf")
  for i in range(N):
    for j in range(i+1,N):
      
      x,y,r=get_circle_2p(xylist[i],xylist[j])
      
      if r>min_radius:
        continue
      
      for l in range(N):
        if l==i or l==j:
          continue
          
        xl,yl=xylist[l]
        diff_xl=xl-x
        diff_yl=yl-y
        if math.sqrt(diff_xl**2+diff_yl**2)>r:
          break
      else:
        min_radius=r
  
  for i in range(N):
    for j in range(i+1,N):
      for k in range(j+1,N):
        
        x,y,r=get_circle_3p(xylist[i],xylist[j],xylist[k])
        
        if r>min_radius:
          continue
        
        for l in range(N):
          if l==i or l==j or l==k:
            continue
            
          xl,yl=xylist[l]
          diff_xl=xl-x
          diff_yl=yl-y
          if math.sqrt(diff_xl**2+diff_yl**2)>r:
            break
        else:
          min_radius=r
  
  print(min_radius)

Solution (Python):
import math
N=int(input())

def get_circle_2p(p1,p2):
  x1,y1=p1
  x2,y2=p2
  
  x=(x1+x2)/2
  y=(y1+y2)/2  
  rad=math.sqrt((x1-x2)**2+(y1-y2)**2)/2
  return x,y,rad

def get_circle_3p(p1,p2,p3):
  x1,y1=p1
  x2,y2=p2
  x3,y3=p3
  d=2*((y1-y3)*(x1-x2)-(y1-y2)*(x1-x3))  
  
  if d==0:
    rad1=math.sqrt((x1-x2)**2+(y1-y2)**2)/2
    rad2=math.sqrt((x1-x3)**2+(y1-y3)**2)/2
    rad3=math.sqrt((x2-x3)**2+(y2-y3)**2)/2
    
    if rad1>=rad2 and rad1>=rad3:
      x=(x1+x2)/2
      y=(y1+y2)/2
      return x,y,rad1
    elif rad2>=rad1 and rad2>=rad3:
      x=(x1+x3)/2
      y=(y1+y3)/2
      return x,y,rad2
    elif rad3>=rad1 and rad3>=rad2:
      x=(x2+x3)/2
      y=(y2+y3)/2
      return x,y,rad3      
  else:
    x=((y1-y3)*(y1**2-y2**2+x1**2-x2**2)-(y1-y2)*(y1**2-y3**2+x1**2-x3**2))/d
    y=((x1-x3)*(x1**2-x2**2+y1**2-y2**2)-(x1-x2)*(x1**2-x3**2+y1**2-y3**2))/-d
    r=math.sqrt((x-x1)**2+(y-y1)**2)
    return (x,y,r)
  
xylist=[]
for i in range(N):
  xi,yi=map(int,input().split())
  xylist.append((xi,yi))
  


if N==2:
  x,y,r=get_circle_2p(xylist[0],xylist[1])
  print(r)
else:
  min_radius=float("inf")
  for i in range(N):
    for j in range(i+1,N):
      
      x,y,r=get_circle_2p(xylist[i],xylist[j])
      
      if r>min_radius:
        continue
      
      for l in range(N):
        if l==i or l==j:
          continue
          
        xl,yl=xylist[l]
        diff_xl=xl-x
        diff_yl=yl-y
        if math.sqrt(diff_xl**2+diff_yl**2)>r:
          break
      else:
        if r<min_radius:
          min_radius=r
  
  for i in range(N):
    for j in range(i+1,N):
      for k in range(j+1,N):
        
        x,y,r=get_circle_3p(xylist[i],xylist[j],xylist[k])
        
        if r>min_radius:
          continue
        
        for l in range(N):
          if l==i or l==j or l==k:
            continue
            
          xl,yl=xylist[l]
          diff_xl=xl-x
          diff_yl=yl-y
          if math.sqrt(diff_xl**2+diff_yl**2)>r:
            break
        else:
          if r<min_radius:
            min_radius=r
  
  print(min_radius)

Solution (Python):
import sys
import math
from collections import defaultdict
from bisect import bisect_left, bisect_right

sys.setrecursionlimit(10**7)
def input():
    return sys.stdin.readline()[:-1]

mod = 10**9 + 7

def I(): return int(input())
def LI(): return list(map(int, input().split()))
def LIR(row,col):
    if row <= 0:
        return [[] for _ in range(col)]
    elif col == 1:
        return [I() for _ in range(row)]
    else:
        read_all = [LI() for _ in range(row)]
        return map(list, zip(*read_all))




def smallest_enclosing_circle(N,x,y):
    if N==2:
        return ((x[0]+x[1])/2, (y[0]+y[1])/2),\
               (((x[0]-x[1])**2 + (y[0]-y[1])**2)**0.5)/2

    
    def three_point_circle(x1,y1,x2,y2,x3,y3):
        a = (y1-y2)*(x1-x3) - (y1-y3)*(x1-x2)
        
        if abs(a) < 10**(-10):
            return (None,None), None
        else:
            A = (x1**2-x2**2) + (y1**2-y2**2)
            B = (x1**2-x3**2) + (y1**2-y3**2)
            x0 = -(A*(y1-y3)-B*(y1-y2)) / (2*a)
            y0 = (A*(x1-x3)-B*(x1-x2)) / (2*a)
            r = ((x1-x0)**2 +(y1-y0)**2)**0.5
            return (x0,y0), r

    r_min = float('inf')
    c_ans = (float('inf'), float('inf'))

    for i in range(N-2):
        for j in range(i+1,N-1):
            for k in range(j+1,N):
                c,r = three_point_circle(x[i],y[i],x[j],y[j],x[k],y[k])
                if r is not None:
                    if r < r_min:
                        check = False
                        for h in range(N):
                            if h in [i,j,k]:
                                continue
                            if (x[h]-c[0])**2 + (y[h]-c[1])**2 > r**2:
                                check = True
                        if not check:
                            r_min = r
                            c_ans = (c[0],c[1])

    for i in range(N-1):
        for j in range(i+1,N):
            c = ((x[i]+x[j])/2, (y[i]+y[j])/2)
            r = (((x[i]-x[j])**2 + (y[i]-y[j])**2)**0.5)/2
            flag = False
            for k in range(N):
                if k in [i,j]:
                    continue
                else:
                    if (x[k]-c[0])**2 + (y[k]-c[1])**2 > r**2:
                        flag = True
                        break
            if not flag:
                if r < r_min:
                    r_min = r
                    c_ans = (c[0],c[1])

    return c_ans,r_min

N = I()
x,y = LIR(N,2)
c,r = smallest_enclosing_circle(N,x,y)
print(r)

Solution (Python):
from scipy import optimize
import numpy as np

n=int(input())
points=[tuple(map(int,input().split())) for i in range(n)]

maxd=0
def d(xy):
    maxd=0
    x,y=xy
    for p in points:
        px,py=p
        d=np.linalg.norm((x-px,y-py))
        if maxd<d:
            maxd=d
    return maxd
opt=optimize.fmin(d,np.zeros(2),ftol=10**(-6),disp=0)
print(d(opt))

Solution (Python):
from math import sqrt

N = int(input())
XY = [tuple(map(int, input().split())) for _ in range(N)]

def calc(r): 
    lst = [] 
    for i in range(N - 1):
        x1 = XY[i][0]
        y1 = XY[i][1]
        for j in range(i + 1, N):
            x2 = XY[j][0]
            y2 = XY[j][1]
            diff = sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2)

            if diff > 2 * r:
                return False
            
            h = sqrt(r ** 2 - (diff / 2) ** 2)
            
            if x1 == x2:
                ny = (y1 + y2) / 2
                lst.append([x1 - h, ny])
                lst.append([x1 + h, ny]) 
            elif y1 == y2:
                nx = (x1 + x2) / 2
                lst.append([nx, y1 - h])
                lst.append([nx, y1 + h])
            else:
                a = (y2 - y1) / (x2 - x1) 

                b = -1 / a

                size = sqrt(1 + b ** 2)

                nx = h / size
                ny = nx * b

                
                xc = (x1 + x2) / 2
                yc = (y1 + y2) / 2

                lst.append([xc + nx, yc + ny])
                lst.append([xc - nx, yc - ny])
    
    
    nr = r + eps
    for x, y in lst: 
        flag = True
        for X, Y in XY:
            tmp = (x - X) ** 2 + (y - Y) ** 2
            if tmp > nr ** 2:
                flag = False
                break
        if flag:
            return True
    return False
    
l = 0
r = 1000

eps = 10 ** (-9)

for i in range(100):
    mid = (l + r) / 2
    if calc(mid):
        r = mid
    else:
        l = mid

print (r)