Language: C++

/*
このコード、と～おれ!
Be accepted!
∧＿∧　
（｡･ω･｡)つ━☆・*。
⊂　　 ノ 　　　・゜+.
　しーＪ　　　°。+ *´¨)
 　　　　　　　　　.· ´¸.·*´¨) ¸.·*¨)
		  　　　　　　　　　　(¸.·´ (¸.·'* ☆
					*/

#include <stdio.h>
#include <algorithm>
#include <string>
#include <cmath>
#include <cstring>
#include <vector>
#include <numeric>
#include <iostream>
#include <random>
#include <map>
#include <unordered_map>
#include <queue>
#include <regex>
#include <functional>
#include <complex>
					/*多倍長整数/cpp_intで宣言
					#include <boost/multiprecision/cpp_int.hpp>

					using namespace boost::multiprecision;
					*/

#pragma GCC target ("avx2")
#pragma GCC optimization ("O3")
#pragma GCC optimization ("unroll-loops")
#define rep(i, n) for(int i = 0; i < (n); ++i)
#define rep1(i, n) for(int i = 1; i <= (n); ++i)
#define rep2(i, n) for(int i = 2; i < (n); ++i)
#define repr(i, n) for(int i = n; i >= 0; --i)
#define reprm(i, n) for(int i = n - 1; i >= 0; --i)
#define printynl(a) printf(a ? "yes\n" : "no\n")
#define printyn(a) printf(a ? "Yes\n" : "No\n")
#define printYN(a) printf(a ? "YES\n" : "NO\n")
#define printin(a) printf(a ? "possible\n" : "inposible\n")
#define printdb(a) printf("%.50lf\n", a)//少数出力
#define printdbd(a) printf("%.16lf\n", a)//少数出力(桁少なめ)
#define prints(s) printf("%s\n", s.c_str())//string出力
#define all(x) (x).begin(), (x).end()
#define allsum(a, b, c) ((a + b) * c / 2)//等差数列の和、初項,末項,項数
#define pb push_back
#define priq priority_queue
#define rpriq priq<int, vector<int>, greater<int>>
#define deg_to_rad(deg) (((deg)/360.0)*2.0*PI)
#define rad_to_deg(rad) (((rad)/2.0/PI)*360.0)
#define Please return
#define AC 0
#define addf(T) [](T a, T b){return (a + b);}
#define minf(T) [](T a, T b){return min(a, b);}
#define maxf(T) [](T a, T b){return max(a, b);}


using ll = long long;

constexpr int INF = 1073741823;
constexpr int MINF = -1073741823;
constexpr ll LINF = ll(4661686018427387903);
constexpr ll MOD = 1000000007;
const long double PI = acos(-1.0L);

using namespace std;

void scans(string& str) {
	char c;
	str = "";
	scanf("%c", &c);
	if (c == '\n')scanf("%c", &c);//最初の改行対策
	while (c != '\n' && c != -1) {
		str += c;
		scanf("%c", &c);
	}
}

void scanc(char& str) {
	char c;
	scanf("%c", &c);
	if (c == -1)return;
	while (c == '\n') {
		scanf("%c", &c);
	}
	str = c;
}

double acot(double x) {
	return PI / 2 - atan(x);
}

ll gcd(ll a, ll b) {
	if (b == 0) return a;
	return gcd(b, a % b);
}

ll lcm(ll number1, ll number2) {//lcmを求める
	return number1 / gcd(number1, number2) * number2;
}

ll LSB(ll n) { return (n & (-n)); }

/*-----------------------------------------ここからコード-----------------------------------------*/

template< int mod >
struct ModInt {
	int x;

	ModInt() : x(0) {}

	ModInt(ll y) : x(y >= 0 ? y % mod : (mod - (-y) % mod) % mod) {}

	ModInt& operator+=(const ModInt& p) {
		if ((x += p.x) >= mod) x -= mod;
		return *this;
	}

	ModInt& operator-=(const ModInt& p) {
		if ((x += mod - p.x) >= mod) x -= mod;
		return *this;
	}

	ModInt& operator*=(const ModInt& p) {
		x = (int)(1LL * x * p.x % mod);
		return *this;
	}

	ModInt& operator/=(const ModInt& p) {
		*this *= p.inverse();
		return *this;
	}

	ModInt operator-() const { return ModInt(-x); }

	ModInt operator+(const ModInt& p) const { return ModInt(*this) += p; }

	ModInt operator-(const ModInt& p) const { return ModInt(*this) -= p; }

	ModInt operator*(const ModInt& p) const { return ModInt(*this) *= p; }

	ModInt operator/(const ModInt& p) const { return ModInt(*this) /= p; }

	bool operator==(const ModInt& p) const { return x == p.x; }

	bool operator!=(const ModInt& p) const { return x != p.x; }

	bool operator>(const ModInt& p) const { return x > p.x; }

	bool operator<(const ModInt& p) const { return x < p.x; }

	bool operator<=(const ModInt& p) const { return x <= p.x; }

	bool operator>=(const ModInt& p) const { return x >= p.x; }

	ModInt inverse() const {
		int a = x, b = mod, u = 1, v = 0, t;
		while (b > 0) {
			t = a / b;
			swap(a -= t * b, b);
			swap(u -= t * v, v);
		}
		return ModInt(u);
	}

	ModInt pow(int64_t n) const {
		ModInt ret(1), mul(x);
		while (n > 0) {
			if (n & 1) ret *= mul;
			mul *= mul;
			n >>= 1;
		}
		return ret;
	}

	friend ostream& operator<<(ostream& os, const ModInt& p) {
		return os << p.x;
	}

	friend istream& operator>>(istream& is, ModInt& a) {
		ll t;
		is >> t;
		a = ModInt< mod >(t);
		return (is);
	}

	static int get_mod() { return mod; }
};

using modint = ModInt< MOD >;//MOD=1e9 + 7
using Modint = ModInt< 998244353 >;

template<typename T>
//0-indexed/内部的に 1-indexed
struct BIT {
	vector<T> tree;
	//初期化
	BIT(ll n) : tree(n) {
		tree.assign(n + 1, 0);
	}

	//[0, n) の sum を返す/0-indexed
	T sum(ll n) {
		T ret = 0;
		//実は 1-indexed だが半開区間なので見た目がそのまま
		for (; n >= 0; n -= LSB(n)) {
			ret += tree[n];
			if (!n)break;
		}
		return ret;
	}

	//n 番目に x を足す
	void add(ll n, T x) {
		ll siz = tree.size();
		for (++n; n < siz; n += LSB(n))tree[n] += x;
	}
};

//nCrを1000000007で割った余りを求める。modint依存
modint nCr(ll a, ll b) {
	modint ans = 1;
	if (a < b)return 0;
	for (ll i = 0; i < b; i++) {
		ans *= a - i;
	}
	for (ll i = 1; i <= b; i++) {
		ans /= i;
	}
	return ans;
}

// #define int int64_t


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 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) {}
};

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;
	scanf("%d", &n);
	vector<P> a(n);
	rep(i, n)scanf("%d%d", &a[i]first, &a[i].second);
	auto x =  min_ball(all(a));
	printdb(sqrt(x.second));

	Please AC;
}


Compiler output:
a.cc:400:27: error: 'iter' was not declared in this scope
  400 | std::pair<P, ld> min_ball(iter left, iter right, int seed = 1333) {
      |                           ^~~~
a.cc:400:38: error: 'iter' was not declared in this scope
  400 | std::pair<P, ld> min_ball(iter left, iter right, int seed = 1333) {
      |                                      ^~~~
a.cc:400:50: error: expected primary-expression before 'int'
  400 | std::pair<P, ld> min_ball(iter left, iter right, int seed = 1333) {
      |                                                  ^~~
a.cc:400:67: error: expected ',' or ';' before '{' token
  400 | std::pair<P, ld> min_ball(iter left, iter right, int seed = 1333) {
      |                                                                   ^
a.cc: In function 'int main()':
a.cc:463:37: error: expected ')' before 'first'
  463 |         rep(i, n)scanf("%d%d", &a[i]first, &a[i].second);
      |                       ~             ^~~~~
      |                                     )
a.cc:463:50: error: '__gnu_cxx::__alloc_traits<std::allocator<std::complex<long double> >, std::complex<long double> >::value_type' {aka 'class std::complex<long double>'} has no member named 'second'
  463 |         rep(i, n)scanf("%d%d", &a[i]first, &a[i].second);
      |                                                  ^~~~~~
a.cc:464:27: error: no match for call to '(std::pair<std::complex<long double>, long double>) (std::vector<std::complex<long double> >::iterator, std::vector<std::complex<long double> >::iterator)'
  464 |         auto x =  min_ball(all(a));
      |                   ~~~~~~~~^~~~~~~~