Language: C++

#include<bits/stdc++.h>
#define REP(i,n) for(int i=0,i##_len=int(n);i<i##_len;++i)
#define rep(i,a,b) for(int i=int(a);i<int(b);++i)
#define All(x) (x).begin(),(x).end()
#define rAll(x) (x).rbegin(),(x).rend()
using namespace std;
using ll = long long;



template <class iter>
std::pair<complex<double>, double> min_ball(iter left, iter right, int seed = 1333) {
    const int n = right - left;
    using P=complex<double>;
    using ld=double;
    const double eps=1e-9;
    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 cross=[](const P& a, const P& b) { return a.real()*b.imag() - a.imag()*b.real(); }
    auto dot=[](const P& a, const P& b) { return a.real()*b.real() + a.imag()*b.imag(); }
    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<complex<double>> pos(N);
    REP(i,N){
        int x,y;
        cin>>x>>y;
        pos[i]=complex<double>(x,y);
    }
    printf("%.16f\n",sqrt(min_ball(All(pos)).second));
}

Compiler output:
a.cc: In function 'std::pair<std::complex<double>, double> min_ball(iter, iter, int)':
a.cc:29:5: error: expected ',' or ';' before 'auto'
   29 |     auto dot=[](const P& a, const P& b) { return a.real()*b.real() + a.imag()*b.imag(); }
      |     ^~~~
a.cc: In lambda function:
a.cc:32:16: error: 'cross' is not captured
   32 |            S = cross(b - a, c - a);
      |                ^~~~~
a.cc:30:27: note: the lambda has no capture-default
   30 |     auto make_circle_3 = [](const P &a, const P &b, const P &c) -> circle {
      |                           ^
a.cc:28:10: note: 'auto cross' declared here
   28 |     auto cross=[](const P& a, const P& b) { return a.real()*b.imag() - a.imag()*b.real(); }
      |          ^~~~~
a.cc: In lambda function:
a.cc:45:53: error: 'eps' is not captured
   45 |         return std::norm(a - c.first) <= c.second + eps;
      |                                                     ^~~
a.cc:44:23: note: the lambda has no capture-default
   44 |     auto in_circle = [](const P &a, const circle &c) -> bool {
      |                       ^
a.cc:16:18: note: 'const double eps' declared here
   16 |     const double eps=1e-9;
      |                  ^~~