Language: C++

#include <bits/stdc++.h>

using namespace std;
using llong = long long;
using ldbl = long double;
using lpair = pair<llong, llong>;

#define ALL(x) x.begin(), x.end()

template<typename T>
constexpr T inf = static_cast<T>(pow(10, static_cast<int>(log10(numeric_limits<T>::max())))) + 7;
constexpr llong mod = 1e9+7;

struct point {
	ldbl x;
	ldbl y;

	point() = default;
	point(ldbl x, ldbl y):
		x(x),
		y(y)
	{}

	point operator+(const point &ri) const {
		return point(x + ri.x, y + ri.y);
	}
};

struct circuit {
	point p;
	ldbl r;

	circuit() = default;
	circuit(point p, ldbl r):
		p(p),
		r(r)
	{}
};

llong N;
vector<point> p;

circuit get_circuit(point p1, point p2, point p3) {
	ldbl a = p1.x - p2.x,
		 b = p1.y - p2.y,
		 c = p2.x - p3.x,
		 d = p2.y - p3.y,
		 x1 = p1.x*p1.x + p1.y*p1.y,
		 x2 = p2.x*p2.x + p2.y*p2.y,
		 x3 = p3.x*p3.x + p3.y*p3.y,
		 x1x2 = x1 - x2,
		 x2x3 = x2 - x3,
		 eps = 1e-8;

	ldbl waru = 1.0 / (2.0l * (a*d - b*c + eps));

	point ret;
	ret.x = waru * (d*x1x2 - b*x2x3);
	ret.y = waru * (-c*x1x2 + a*x2x3);

	return circuit(ret, (p1.x - ret.x)*(p1.x - ret.x) + (p1.y - ret.y)*(p1.y - ret.y));
}

circuit get_circuit(point p1, point p2) {
	point res((p1.x + p2.x)/2.0, (p1.y + p2.y)/2.0);

	return circuit(res, (p1.x - res.x)*(p1.x - res.x) + (p1.y - res.y)*(p1.y - res.y));
}

ldbl dis(point p1, point p2) {
	return (p1.x - p2.x)*(p1.x - p2.x) + (p1.y - p2.y)*(p1.y - p2.y);
}

ldbl solve() {
	circuit ret(point(500l, 500l), 10000000l);

	for (int i = 0; i < N; ++i) {
		for (int j = i + 1; j < N; ++j) {
			circuit D = get_circuit(p[i], p[j]);
			bool check = true;
			for (int k = 0; k < N; ++k) {
				ldbl d = dis(D.p, p[k]);
				if (d > D.r) check = false;
			}
			if (check) {
				return D;
			}
			else {
				D = circuit(point(0, 0,), 0);
				for (int k = 0; k < N; ++k) {
					if (dis(p[k], D.p) > D.r) continue;
					circuit DD = get_circuit(p[i], p[j], p[k]);
					if (D.r < DD.r) D = DD;
				}
				bool check = true;
				for (int k = 0; k < N; ++k) {
					ldbl d = dis(D.p, p[k]);
					if (d > D.r) check = false;
				}
				if (check & D.r < ret.r) {
					ret = D;
				}
			}
		}
	}

	// for (int i = 0; i < N; ++i) {
	// 	for (int j = i + 1; j < N; ++j) {
	// 		for (int k = j + 1; k < N; ++k) {
	// 			circuit D2 = get_circuit(p[])

	// 			circuit D = get_circuit(p[i], p[j], p[k]);
	// 			if (D.r < ret.r) {
	// 				bool check = true;
	// 				for (int h = 0; h < N; ++h) {
	// 					if (h == i || h == j || h == k) continue;
	// 					if ((D.p.x - p[h].x)*(D.p.x - p[h].x) + (D.p.y - p[h].y)*(D.p.y - p[h].y) > D.r)
	// 						check = false;
	// 				}
	// 				if (check) ret = D;
	// 			}
	// 		}
	// 	}
	// }

	return sqrtl(ret.r);
}

int main() {
	cin >> N;
	p.resize(N);
	for (auto &in: p) {
		cin >> in.x >> in.y;
	}

	if (N == 2) {
		point res((p[0].x + p[1].x)/2.0, (p[0].y + p[1].y)/2.0);
		cout << fixed << setprecision(30) << sqrtl((p[0].x - res.x)*(p[0].x - res.x) + (p[0].y - res.y)*(p[0].y - res.y)) << endl;
	}
	else {
		cout << fixed << setprecision(30) << solve() << endl;
	}

	return 0;
}

Compiler output:
a.cc: In function 'ldbl solve()':
a.cc:86:40: error: cannot convert 'circuit' to 'ldbl' {aka 'long double'} in return
   86 |                                 return D;
      |                                        ^
      |                                        |
      |                                        circuit
a.cc:89:44: error: expected primary-expression before '(' token
   89 |                                 D = circuit(point(0, 0,), 0);
      |                                            ^
a.cc:89:50: error: expected primary-expression before '(' token
   89 |                                 D = circuit(point(0, 0,), 0);
      |                                                  ^
a.cc:89:56: error: expected primary-expression before ')' token
   89 |                                 D = circuit(point(0, 0,), 0);
      |                                                        ^