Language: C++

#define _USE_MATH_DEFINES

#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <cmath>
#include <cstring>
#include <algorithm>
#include <vector>
#include <queue>
#include <map>
#include <set>
#include <unordered_map> 
#include <unordered_set>
#include <functional>
#include <bitset>

using namespace std;

typedef pair<long long int, long long int> P;
typedef tuple<int, int, int> T;

long long int INF = 1e18;
long long int MOD = 1e9 + 7;

double EPS = 1e-10;

double add(double a, double b){
	if(abs(a + b) < EPS * (abs(a) + abs(b))){
		return 0;
	}
	return a + b;
}

struct Pd{
	double x, y;
	Pd(){}
	Pd(double x, double y) : x(x), y(y){}
	Pd operator + (Pd p){
		return Pd(add(x, p.x), add(y, p.y));
	}
	Pd operator - (Pd p){
		return Pd(add(x, -p.x), add(y, -p.y));
	}
	Pd operator * (double d){
		return Pd(x * d, y * d);
	}
	double dot(Pd p){
		return add(x * p.x, y * p.y);
	}
	double det(Pd p){
		return add(x * p.y, -y * p.x);
	}
};

pair<Pd, double> min_ball(vector<Pd> ps) {
    const int n = ps.size();
 
    //assert(n >= 1); // n < 1 の場合、エラーメッセージを出力して異常終了
    if (n == 1) {
        return {ps[0], 0.0};
    }

    using circle = pair<Pd, double>;
 
    auto make_circle_3 = [](Pd a, Pd b, Pd c) -> circle {
        double A = (b - c) * (b - c), B = (c - a) * (c - a), C = (a - b) * (a - b), S = Pd(b - a).det(c - a);
        Pd p = (a * A * (B + C - A) + b * B * (C + A - B) + c * C * (A + B - C)) * (1.0 / (4 * S * S));
        double r2 = (p - a) * (p - a);
        return {p, r2};
    };
 
    auto make_circle_2 = [](Pd a, Pd b) -> circle {
        Pd c = (a + b) * 0.5;
        double r2 = (a - c) * (a - c);
        return {c, r2};
    };
 
    auto in_circle = [](Pd a, circle c) -> bool {
        return (a - c.first) * (a - c.first) <= c.second + EPS;
    };

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

    for (int i = 2; i < n; ++i) {
        if (!in_circle(ps[i], c)) {
            c = make_circle_2(ps[0], ps[i]);
            for (int j = 1; j < i; ++j) {
                if (!in_circle(ps[j], c)) {
                    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<Pd> v;
	for(int i = 0; i < N; i++){
		Pd p = Pd();
		cin >> p.x >> p.y;
		v.push_back(p);
	}
	printf("%.15f\n", sqrt(min_ball(v).second));
	return 0;
}

Compiler output:
a.cc: In lambda function:
a.cc:67:28: error: no match for 'operator*' (operand types are 'Pd' and 'Pd')
   67 |         double A = (b - c) * (b - c), B = (c - a) * (c - a), C = (a - b) * (a - b), S = Pd(b - a).det(c - a);
      |                    ~~~~~~~ ^ ~~~~~~~
      |                       |         |
      |                       Pd        Pd
a.cc:45:12: note: candidate: 'Pd Pd::operator*(double)'
   45 |         Pd operator * (double d){
      |            ^~~~~~~~
a.cc:45:31: note:   no known conversion for argument 1 from 'Pd' to 'double'
   45 |         Pd operator * (double d){
      |                        ~~~~~~~^
a.cc:68:26: error: 'B' was not declared in this scope
   68 |         Pd p = (a * A * (B + C - A) + b * B * (C + A - B) + c * C * (A + B - C)) * (1.0 / (4 * S * S));
      |                          ^
a.cc:68:30: error: 'C' was not declared in this scope
   68 |         Pd p = (a * A * (B + C - A) + b * B * (C + A - B) + c * C * (A + B - C)) * (1.0 / (4 * S * S));
      |                              ^
a.cc:68:96: error: 'S' was not declared in this scope
   68 |         Pd p = (a * A * (B + C - A) + b * B * (C + A - B) + c * C * (A + B - C)) * (1.0 / (4 * S * S));
      |                                                                                                ^
a.cc:69:29: error: no match for 'operator*' (operand types are 'Pd' and 'Pd')
   69 |         double r2 = (p - a) * (p - a);
      |                     ~~~~~~~ ^ ~~~~~~~
      |                        |         |
      |                        Pd        Pd
a.cc:45:12: note: candidate: 'Pd Pd::operator*(double)'
   45 |         Pd operator * (double d){
      |            ^~~~~~~~
a.cc:45:31: note:   no known conversion for argument 1 from 'Pd' to 'double'
   45 |         Pd operator * (double d){
      |                        ~~~~~~~^
a.cc: In lambda function:
a.cc:75:29: error: no match for 'operator*' (operand types are 'Pd' and 'Pd')
   75 |         double r2 = (a - c) * (a - c);
      |                     ~~~~~~~ ^ ~~~~~~~
      |                        |         |
      |                        Pd        Pd
a.cc:45:12: note: candidate: 'Pd Pd::operator*(double)'
   45 |         Pd operator * (double d){
      |            ^~~~~~~~
a.cc:45:31: note:   no known conversion for argument 1 from 'Pd' to 'double'
   45 |         Pd operator * (double d){
      |                        ~~~~~~~^
a.cc: In lambda function:
a.cc:80:30: error: no match for 'operator*' (operand types are 'Pd' and 'Pd')
   80 |         return (a - c.first) * (a - c.first) <= c.second + EPS;
      |                ~~~~~~~~~~~~~ ^ ~~~~~~~~~~~~~
      |                   |               |
      |                   Pd              Pd
a.cc:45:12: note: candidate: 'Pd Pd::operator*(double)'
   45 |         Pd operator * (double d){
      |            ^~~~~~~~
a.cc:45:31: note:   no known conversion for argument 1 from 'Pd' to 'double'
   45 |         Pd operator * (double d){
      |                        ~~~~~~~^