Language: C++

#include <cassert>
#include <cstdio>
#include <cmath>
#include <iostream>
#include <iomanip>
#include <sstream>
#include <vector>
#include <set>
#include <map>
#include <queue>
#include <numeric>
#include <algorithm>

using namespace std;
using lint = long long;
constexpr int MOD = 1000000007, INF = 1010101010;
constexpr lint LINF = 1LL << 60;

template <class T>
ostream &operator<<(ostream &os, const vector<T> &vec) {
	for (const auto &e : vec) os << e << (&e == &vec.back() ? "\n" : " ");
	return os;
}

#ifdef _DEBUG
template <class T>
void dump(const char* str, T &&h) { cerr << str << " = " << h << "\n"; };
template <class Head, class... Tail>
void dump(const char* str, Head &&h, Tail &&... t) {
	while (*str != ',') cerr << *str++; cerr << " = " << h << "\n";
	dump(str + (*(str + 1) == ' ' ? 2 : 1), t...);
}
#define DMP(...) dump(#__VA_ARGS__, __VA_ARGS__)
#else 
#define DMP(...) ((void)0)
#endif

using ld = long double;
constexpr ld EPS = 1e-12;

struct pnt {
	ld x, y;
	constexpr pnt(ld x = 0, ld y = 0) noexcept : x(x), y(y) {};
	constexpr bool operator==(const pnt &rhs) const noexcept { return x == rhs.x && y == rhs.y; }
	constexpr bool operator<(const pnt & rhs) const noexcept { return x < rhs.x || x == rhs.x && y < rhs.y; }
	constexpr pnt operator+(const pnt &rhs) const noexcept { return pnt(x + rhs.x, y + rhs.y); }
	constexpr pnt operator-(const pnt &rhs) const noexcept { return pnt(x - rhs.x, y - rhs.y); }
	constexpr pnt operator-() const noexcept { return pnt(-x, -y); }
	constexpr pnt operator*(const ld &k) const noexcept { return pnt(k * x, k * y); }
	friend istream& operator>>(istream& is, pnt &p) { return is >> p.x >> p.y; }
	friend ostream& operator<<(ostream& os, const pnt &p) { return os << p.x << " " << p.y << "\n"; }
	template<class T> T& operator[](vector<vector<T>> &v) { return v[x][y]; }
};

ld dist(const pnt &p, const pnt &q) { return hypot(p.x - q.x, p.y - q.y); };
pnt mid(const pnt &p, const pnt &q) { return pnt((p.x + q.x) / 2, (p.y + q.y) / 2); };
pnt nor(const pnt &p) { return pnt(p.y, -p.x); }

pair<pnt, pnt> center(pnt p, pnt q, ld radius) {

	pnt m = mid(p, q);
	ld half = dist(p, q) / 2;
	ld len = sqrt((radius / half)*(radius / half) - 1) / 2;
	//DMP(m, half, len);

	//法線ベクトル
	pnt norm = nor(p - q);
	//DMP(norm);

	pnt res1 = m + norm * len;
	pnt res2 = m - norm * len;

	return { res1, res2 };

};

template<class T>
inline bool chmin(T &a, const T b) { return a > b && (a = b, true); }

template <class iter>
std::pair<pnt, 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<pnt, ld>;

	auto make_circle_3 = [](const pnt &a, const pnt &b, const pnt &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 pnt &a, const pnt &b) -> circle {
		P c = (a + b) / (ld)2;
		ld r2 = std::norm(a - c);
		return { c, r2 };
	};

	auto in_circle = [](const pnt &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() {

	cin.tie(nullptr);
	ios::sync_with_stdio(false);

	int N;
	cin >> N;

	vector<pnt> xy(N);
	for (int i = 0; i < N; i++) cin >> xy[i].x >> xy[i].y;

	//DMP(center(pnt(0, 0), pnt(1, 1), 0.5).first);

	ld ans = INF;

	cout << setprecision(20) << min_ball<decltype(xy.begin())>(xy.begin(), xy.end()).second << "\n";

	return 0;
}

Compiler output:
a.cc: In function 'std::pair<pnt, long double> min_ball(iter, iter, int)':
a.cc:89:14: error: 'mt19937' is not a member of 'std'
   89 |         std::mt19937 mt(seed);
      |              ^~~~~~~
a.cc:90:35: error: 'mt' was not declared in this scope; did you mean 'tm'?
   90 |         std::shuffle(left, right, mt);
      |                                   ^~
      |                                   tm
a.cc: In lambda function:
a.cc:97:29: error: 'norm' is not a member of 'std'
   97 |                 ld A = std::norm(b - c), B = std::norm(c - a), C = std::norm(a - b),
      |                             ^~~~
a.cc:99:17: error: 'P' was not declared in this scope
   99 |                 P p = (A * (B + C - A) * a + B * (C + A - B) * b + C * (A + B - C) * c) / (4 * S * S);
      |                 ^
a.cc:100:30: error: 'norm' is not a member of 'std'
  100 |                 ld r2 = std::norm(p - a);
      |                              ^~~~
a.cc:100:35: error: 'p' was not declared in this scope; did you mean 'ps'?
  100 |                 ld r2 = std::norm(p - a);
      |                                   ^
      |                                   ps
a.cc:101:32: error: could not convert '{p, r2}' from '<brace-enclosed initializer list>' to 'circle' {aka 'std::pair<pnt, long double>'}
  101 |                 return { p, r2 };
      |                                ^
      |                                |
      |                                <brace-enclosed initializer list>
a.cc: In lambda function:
a.cc:105:17: error: 'P' was not declared in this scope
  105 |                 P c = (a + b) / (ld)2;
      |                 ^
a.cc:106:30: error: 'norm' is not a member of 'std'
  106 |                 ld r2 = std::norm(a - c);
      |                              ^~~~
a.cc:106:39: error: 'c' was not declared in this scope
  106 |                 ld r2 = std::norm(a - c);
      |                                       ^
a.cc:107:32: error: could not convert '{c, r2}' from '<brace-enclosed initializer list>' to 'circle' {aka 'std::pair<pnt, long double>'}
  107 |                 return { c, r2 };
      |                                ^
      |                                |
      |                                <brace-enclosed initializer list>
a.cc: In lambda function:
a.cc:111:29: error: 'norm' is not a member of 'std'
  111 |                 return std::norm(a - c.first) <= c.second + eps;
      |                             ^~~~
a.cc:111:61: error: 'eps' was not declared in this scope; did you mean 'ps'?
  111 |                 return std::norm(a - c.first) <= c.second + eps;
      |                                                             ^~~
      |                                                             ps