Language: C++

#include <bits/stdc++.h>
// #define int int64_t

#define FOR(i, a, b) for (int i = (a); i < int(b); ++i)
#define RFOR(i, a, b) for (int i = (b)-1; i >= int(a); --i)
#define rep(i, n) FOR(i, 0, n)
#define rep1(i, n) FOR(i, 1, int(n) + 1)
#define rrep(i, n) RFOR(i, 0, n)
#define rrep1(i, n) RFOR(i, 1, int(n) + 1)
#define all(c) begin(c), end(c)
namespace io {
#ifdef LOCAL
#define dump(...)                                         \
    do {                                                  \
        std::ostringstream os;                            \
        os << __LINE__ << ":\t" << #__VA_ARGS__ << " = "; \
        io::print_to(os, ", ", "\n", __VA_ARGS__);        \
        std::cerr << io::highlight(os.str());             \
    } while (0)
#define dump_(cntnr)                                 \
    do {                                             \
        std::ostringstream os;                       \
        os << __LINE__ << ":\t" << #cntnr << " = ["; \
        io::print_to_(os, ", ", "]\n", all(cntnr));  \
        std::cerr << io::highlight(os.str());        \
    } while (0)
#define dumpf(fmt, ...)                             \
    do {                                            \
        const int N = 4096;                         \
        auto b = new char[N];                       \
        int l = snprintf(b, N, "%d:\t", __LINE__);  \
        snprintf(b + l, N - l, fmt, ##__VA_ARGS__); \
        std::cerr << io::highlight(b) << std::endl; \
        delete[] b;                                 \
    } while (0)
#else
#define dump(...)
#define dump_(...)
#define dumpf(...)
#endif
std::string highlight(std::string s) {
#ifdef _MSC_VER
    return s;
#else
    return "\033[33m" + s + "\033[0m";
#endif
}
template <typename T>
void print_to(std::ostream &os, std::string, std::string tail, const T &first) {
    os << first << tail;
}
template <typename F, typename... R>
void print_to(std::ostream &os, std::string del, std::string tail, const F &first,
              const R &... rest) {
    os << first << del;
    print_to(os, del, tail, rest...);
}
template <typename I>
void print_to_(std::ostream &os, std::string del, std::string tail, I begin, I end) {
    for (I it = begin; it != end;) {
        os << *it;
        os << (++it != end ? del : tail);
    }
}
template <typename F, typename... R>
void println(const F &first, const R &... rest) {
    print_to(std::cout, "\n", "\n", first, rest...);
}
template <typename F, typename... R>
void print(const F &first, const R &... rest) {
    print_to(std::cout, " ", "\n", first, rest...);
}
template <typename I>
void println_(I begin, I end) {
    print_to_(std::cout, "\n", "\n", begin, end);
}
template <typename I>
void print_(I begin, I end) {
    print_to_(std::cout, " ", "\n", begin, end);
}
template <typename C>
void println_(const C &cntnr) {
    println_(std::begin(cntnr), std::end(cntnr));
}
template <typename C>
void print_(const C &cntnr) {
    print_(std::begin(cntnr), std::end(cntnr));
}
int _ = (
#ifndef LOCAL
    std::cin.tie(nullptr), std::ios::sync_with_stdio(false),
#endif
    std::cout.precision(10), std::cout.setf(std::ios::fixed));
}
using io::print;
using io::println;
using io::println_;
using io::print_;
template <typename T>
using vec = std::vector<T>;
using vi = vec<int>;
using vvi = vec<vi>;
using pii = std::pair<int, int>;
using ll = long long;
using ld = long double;
using namespace std;
// const int MOD = 1000000007;

using ld = long double;
using P = std::complex<ld>;
using G = std::vector<P>;
const ld pi = std::acos(-1);
const ld eps = 1e-10;
const ld inf = 1e12;

ld cross(const P &a, const P &b) { return a.real() * b.imag() - a.imag() * b.real(); }
ld dot(const P &a, const P &b) { return a.real() * b.real() + a.imag() * b.imag(); }

/*
                    CCW

 -- BEHIND -- [a -- ON -- b] --- FRONT --

                    CW
 */
enum CCW_RESULT { CCW = +1, CW = -1, BEHIND = +2, FRONT = -2, ON = 0 };
int ccw(P a, P b, P c) {
    b -= a;
    c -= a;
    if (cross(b, c) > eps) return CCW;    // counter clockwise
    if (cross(b, c) < -eps) return CW;    // clockwise
    if (dot(b, c) < 0) return BEHIND;     // c--a--b on line
    if (norm(b) < norm(c)) return FRONT;  // a--b--c on line
    return ON;
}

namespace std {
bool operator<(const P &a, const P &b) {
    return std::abs(real(a) - real(b)) > eps ? real(a) < real(b) : imag(a) < imag(b);
}
}

struct L : public std::vector<P> {
    L(const P &a = P(), const P &b = P()) : std::vector<P>(2) {
        begin()[0] = a;
        begin()[1] = b;
    }

    // Ax + By + C = 0
    L(ld A, ld B, ld C) {
        if (std::abs(A) < eps && std::abs(B) < eps) {
            abort();
        } else if (std::abs(A) < eps) {
            *this = L(P(0, -C / B), P(1, -C / B));
        } else if (std::abs(B) < eps) {
            *this = L(P(-C / A, 0), P(-C / A, 1));
        } else {
            *this = L(P(0, -C / B), P(-C / A, 0));
        }
    }
};

struct C {
    P p;
    ld r;
    C(const P &p = 0, ld r = 0) : p(p), r(r) {}
};
template <class iter>
std::pair<P, ld> min_ball(iter left, iter right, int seed = 1333) {
    const int n = right - left;

    assert(n >= 1);
    if (n == 1) {
        return {*left, ld(0)};
    }

    std::mt19937 mt(seed);
    std::shuffle(left, right, mt);
    // std::random_shuffle(left, right); // simple but deprecated

    iter ps = left;
    using circle = std::pair<P, ld>;

    auto make_circle_3 = [](const P &a, const P &b, const P &c) -> circle {
        ld A = std::norm(b - c), B = std::norm(c - a), C = std::norm(a - b),
           S = cross(b - a, c - a);
        P p = (A * (B + C - A) * a + B * (C + A - B) * b + C * (A + B - C) * c) / (4 * S * S);
        ld r2 = std::norm(p - a);
        return {p, r2};
    };

    auto make_circle_2 = [](const P &a, const P &b) -> circle {
        P c = (a + b) / (ld)2;
        ld r2 = std::norm(a - c);
        return {c, r2};
    };

    auto in_circle = [](const P &a, const circle &c) -> bool {
        return std::norm(a - c.first) <= c.second + eps;
    };

    circle c = make_circle_2(ps[0], ps[1]);

    // MiniDisc
    for (int i = 2; i < n; ++i) {
        if (!in_circle(ps[i], c)) {
            // MiniDiscWithPoint
            c = make_circle_2(ps[0], ps[i]);
            for (int j = 1; j < i; ++j) {
                if (!in_circle(ps[j], c)) {
                    // MiniDiscWith2Points
                    c = make_circle_2(ps[i], ps[j]);
                    for (int k = 0; k < j; ++k) {
                        if (!in_circle(ps[k], c)) {
                            c = make_circle_3(ps[i], ps[j], ps[k]);
                        }
                    }
                }
            }
        }
    }
    return c;
}
int main(){
    int n;cin>>n;
    vector<pair<ld,ld> >a(n);
    for(int i=0;i<n;i++){
        cin>>a[i].first>>a[i].second;
    }
    pair<P, ld>k=min_ball(a.begin(),a.end(),1333);
    cout<<setprecision(10)<<sqrt(k.second)<<endl;
}

Compiler output:
a.cc: In instantiation of 'std::pair<std::complex<long double>, long double> min_ball(iter, iter, int) [with iter = __gnu_cxx::__normal_iterator<std::pair<long double, long double>*, std::vector<std::pair<long double, long double> > >]':
a.cc:230:26:   required from here
  230 |     pair<P, ld>k=min_ball(a.begin(),a.end(),1333);
      |                  ~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~
a.cc:174:29: error: could not convert '{left.__gnu_cxx::__normal_iterator<std::pair<long double, long double>*, std::vector<std::pair<long double, long double> > >::operator*(), (ld)0}' from '<brace-enclosed initializer list>' to 'std::pair<std::complex<long double>, long double>'
  174 |         return {*left, ld(0)};
      |                             ^
      |                             |
      |                             <brace-enclosed initializer list>
a.cc:202:29: error: no match for call to '(min_ball<__gnu_cxx::__normal_iterator<std::pair<long double, long double>*, std::vector<std::pair<long double, long double> > > >(__gnu_cxx::__normal_iterator<std::pair<long double, long double>*, std::vector<std::pair<long double, long double> > >, __gnu_cxx::__normal_iterator<std::pair<long double, long double>*, std::vector<std::pair<long double, long double> > >, int)::<lambda(const P&, const P&)>) (std::pair<long double, long double>&, std::pair<long double, long double>&)'
  202 |     circle c = make_circle_2(ps[0], ps[1]);
      |                ~~~~~~~~~~~~~^~~~~~~~~~~~~~
a.cc:202:29: note: candidate: 'circle (*)(const P&, const P&)' {aka 'std::pair<std::complex<long double>, long double> (*)(const std::complex<long double>&, const std::complex<long double>&)'} (conversion)
a.cc:202:29: note:   candidate expects 3 arguments, 3 provided
a.cc:192:26: note: candidate: 'min_ball<__gnu_cxx::__normal_iterator<std::pair<long double, long double>*, std::vector<std::pair<long double, long double> > > >(__gnu_cxx::__normal_iterator<std::pair<long double, long double>*, std::vector<std::pair<long double, long double> > >, __gnu_cxx::__normal_iterator<std::pair<long double, long double>*, std::vector<std::pair<long double, long double> > >, int)::<lambda(const P&, const P&)>'
  192 |     auto make_circle_2 = [](const P &a, const P &b) -> circle {
      |                          ^
a.cc:192:26: note:   no known conversion for argument 1 from 'std::pair<long double, long double>' to 'const P&' {aka 'const std::complex<long double>&'}
a.cc:206:23: error: no match for call to '(min_ball<__gnu_cxx::__normal_iterator<std::pair<long double, long double>*, std::vector<std::pair<long double, long double> > > >(__gnu_cxx::__normal_iterator<std::pair<long double, long double>*, std::vector<std::pair<long double, long double> > >, __gnu_cxx::__normal_iterator<std::pair<long double, long double>*, std::vector<std::pair<long double, long double> > >, int)::<lambda(const P&, const circle&)>) (std::pair<long double, long double>&, circle&)'
  206 |         if (!in_circle(ps[i], c)) {
      |              ~~~~~~~~~^~~~~~~~~~
a.cc:206:23: note: candidate: 'bool (*)(const P&, const circle&)' {aka 'bool (*)(const std::complex<long double>&, const std::pair<std::complex<long double>, long double>&)'} (conversion)
a.cc:206:23: note:   candidate expects 3 arguments, 3 provided
a.cc:198:22: note: candidate: 'min_ball<__gnu_cxx::__normal_iterator<std::pair<long double, long double>*, std::vector<std::pair<long double, long double> > > >(__gnu_cxx::__normal_iterator<std::pair<long double, long double>*, std::vector<std::pair<long double, long double> > >, __gnu_cxx::__normal_iterator<std::pair<long double, long double>*, std::vector<std::pair<long double, long double> > >, int)::<lambda(const P&, const circle&)>'
  198 |     auto in_circle = [](const P &a, const circle &c) -> bool {
      |                      ^
a.cc:198:22: note:   no known conversion for argument 1 from 'std::pair<long double, long double>' to 'const P&' {aka 'const std::complex<long double>&'}
a.cc:208:30: error: no match for call to '(min_ball<__gnu_cxx::__normal_iterator<std::pair<long double, long double>*, std::vector<std::pair<long double, long double> > > >(__gnu_cxx::__normal_iterator<std::pair<long double, long double>*, std::vector<std::pair<long double, long double> > >, __gnu_cxx::__normal_iterator<std::pair<long double, long double>*, std::vector<std::pair<long double, long double> > >, int)::<lambda(const P&, const P&)>) (std::pair<long double, long double>&, std::pair<long double, long double>&)'
  208 |             c = make_circle_2(ps[0], ps[i]);
      |                 ~~~~~~~~~~~~~^~~~~~~~~~~~~~
a.cc:208:30: note: candidate: 'circle (*)(const P&, const P&)' {aka 'std::pair<std::complex<long double>, long double> (*)(const std::complex<long double>&, const std::complex<long double>&)'} (conversion)
a.cc:208:30: note:   candidate expects 3 arguments, 3 provided
a.cc:192:26: note: candidate: 'min_ball<__gnu_cxx::__normal_iterator<std::pair<long double, long double>*, std::vector<std::pair<long double, long double> > > >(__gnu_cxx::__normal_iterator<std::pair<long double, long double>*, std::vector<std::pair<long double, long double> > >, __gnu_cxx::__normal_iterator<std::pair<long double, long double>*, std::vector<std::pair<long double, long double> > >, int)::<lambda(const P&, const P&)>'
  192 |     auto make_circle_2 = [](const P &a, const P &b) -> circle {
      |                          ^
a.cc:192:26: note:   no known conversion for argument 1 from 'std::pair<long double, long double>' to 'const P&' {aka 'const std::complex<long double>&'}
a.cc:210:31: error: no match for call to '(min_ball<__gnu_cxx::__normal_iterator<std::pair<long double, long double>*, std::vector<std::pair<long double, long double> > > >(__gnu_cxx::__normal_iterator<std::pair<long double, long double>*, std::vector<std::pair<long double, long double> > >, __gnu_cxx::__normal_iterator<std::pair<long double, long double>*, std::vector<std::pair<long double, long double> > >, int)::<lambda(const P&, const circle&)>) (std::pair<long double, long double>&, circle&)'
  210 |                 if (!in_circle(ps[j], c)) {
      |                      ~~~~~~~~~^~~~~~~~~~
a.cc:210:31: note: candidate: 'bool (*)(const P&, const circle&)' {aka 'bool (*)(const std::complex<long double>&, const std::pair<std::complex<long double>, long double>&)'} (conversion)
a.cc:210:31: note:   candidate expects 3 arguments, 3 provided
a.cc:198:22: note: candidate: 'min_ball<__gnu_cxx::__normal_iterator<std::pair<long double, long double>*, std::vector<std::pair<long double, long double> > > >(__gnu_cxx::__normal_iterator<std::pair<long double, long double>*, std::vector<std::pair<long double, long double> > >, __gnu_cxx::__normal_iterator<std::pair<long double, long double>*, std::vector<std::pair<long double, long double> > >, int)::<lambda(const P&, const circle&)>'
  198 |     auto in_circle = [](const P &a, const circle &c) -> bool {
      |                      ^
a.cc:198:22: note:   no known conversion for argument 1 from 'std::pair<long double, long double>' to 'const P&' {aka 'const std::complex<long double>&'}
a.cc:212:38: error: no match for call to '(min_ball<__gnu_cxx::__normal_iterator<std::pair<long double, long double>*, std::vector<std::pair<long double, long double> > > >(__gnu_cxx::__normal_iterator<std::pair<long double, long double>*, std::vector<std::pair<long double, long double> > >, __gnu_cxx::__normal_iterator<std::pair<long double, long double>*, std::vector<std::pair<long double, long double> > >, int)::<lambda(const P&, const P&)>) (std::pair<long double, long double>&, std::pair<long double, long double>&)'
  212 |                     c = make_circle_2(ps[i], ps[j]);
      |                         ~~~~~~~~~~~~~^~~~~~~~~~~~~~
a.cc:212:38: note: candidate: 'circle (*)(const P&, const P&)' {aka 'std::pair<std::complex<long double>, long double> (*)(const std::complex<long double>&, const std::complex<long double>&)'} (conversion)
a.cc:212:38: note:   candidate expects 3 arguments, 3 provided
a.cc:192:26: note: candidate: 'min_ball<__gnu_cxx::__normal_iterator<std::pair<long double, long double>*, std::vector<std::pair<long double, long double> > > >(__gnu_cxx::__normal_iterator<std::pair<long double, long double>*, std::vector<std::pair<long double, long double> > >, __gnu_cxx::__normal_iterator<std::pair<long double, long double>*, std::vector<std::pair<long double, long double> > >, int)::<lambda(const P&, const P&)>'
  192 |     auto make_circle_2 = [](const P &a, const P &b) -> circle {
      |                          ^
a.cc:192:26: note:   no known conversion for argument 1 from 'std::pair<long double, long double>' to 'const P&' {aka 'const std::complex<long double>&'}
a.cc:214:39: error: no match for call to '(min_ball<__gnu_cxx::__normal_iterator<std::pair<long double, long double>*, std::vector<std::pair<long double, long double> > > >(__gnu_cxx::__normal_iterator<std::pair<long double, long double>*, std::vector<std::pair<long double, long double> > >, __gnu_cxx::__normal_iterator<std::pair<long double, long double>*, std::vector<std::pair<long double, long double> > >, int)::<lambda(const P&, const circle&)>) (std::pair<long double, long double>&, circle&)'
  214 |                         if (!in_circle(ps[k], c)) {
      |                              ~~~~~~~~~^~~~~~~~~~
a.cc:214:39: note: candidate: 'bool (*)(const P&, const circle&)' {aka 'bool (*)(const std::complex<long double>&, const std::pair<std::complex<long double>, long double>&)'} (conversion)
a.cc:214:39: note:   candidate expects 3 arguments, 3 provided
a.cc:198:22: note: candidate: 'min_ball<__gnu_cxx::__normal_iterator<std::pair<long double, long double>*, std::vector<std::pair<long double, long double> > > >(__gnu_cxx::__normal_iterator<std::pair<long double, long double>*, std::vector<std::pair<long double, long double> > >, __gnu_cxx::__normal_iterator<std::pair<long double, long double>*, std::vector<std::pair<long double, long double> > >, int)::<lambda(const P&, const circle&)>'
  198 |     auto in_circle = [](const P &a, const circle &c) -> bool {
      |                      ^
a.cc:198:22: note:   no known conversion for argument 1 from 'std::pa