Language: C++

#include <iostream>
#include <iomanip>
#include <complex>
#include <vector>
#include <algorithm>
#include <cmath>
#include <array>
using namespace std;
#define X real()
#define Y imag()
typedef complex<long double> P;
typedef vector<P> VP;
const long double EPS = 1e-8;
const long double INF = 1e12;
struct L : array<P, 2>{
    L(const P& a, const P& b){ at(0)=a; at(1)=b; }
    L(){}
};
long double dot(P a, P b){
    return (conj(a)*b).X;
}
long double cross(P a, P b){
    return (conj(a)*b).Y;
}

bool isParallel(const P &a, const P &b){
    return abs(cross(a,b)) < EPS;
}
bool isParallel(const L &a, const L &b){
    return isParallel(a[1]-a[0], b[1]-b[0]);
}

P crosspointLL(const L &l, const L &m) {
  long double A = cross(l[1]-l[0], m[1]-m[0]);
  long double B = cross(l[1]-l[0], l[1]-m[0]);
  return m[0] + B/A *(m[1]-m[0]);
}

L bisect_line(P a, P b){
    P mid = (a+b) *0.5;
    P vert = (a-b) *P(0, 1);
    return L(mid, vert);
}

int main(){
    int n;
    cin >> n;
    VP p(n);
    for(int i=0; i<n; i++){
        long double x,y;
        cin >> x >> y;
        p[i] = P(x, y);
    }

    long double ans = INF;
    for(int i=0; i<n; i++){
        for(int j=i+1; j<n; j++){
            P mid = (p[i]+p[j]) *0.5;
            long double r = abs(p[i] -mid);
            bool ok = true;
            for(int k=0; k<n; k++){
                if(abs(mid -p[k]) > r +EPS){
                    ok = false;
                    break;
                }
            }
            if(ok){
                ans = min(ans, r);
            }
        }
    }

    for(int i=0; i<n; i++){
        for(int j=i+1; j<n; j++){
            for(int k=j+1; k<n; k++){
                L lij = bisect_line(p[i], p[j]);
                L lik = bisect_line(p[i], p[k]);
                if(isParallel(lij, lik)) continue;
                P cp = crosspointLL(lij, lik);
                bool ok = true;
                long double r = abs(p[j] -cp);
                for(int l=0; l<n; l++){
                    if(abs(cp -p[l]) > r +EPS){
                        ok = false;
                        break;
                    }
                }
                if(ok){
                    ans = min(ans, r);
                }
            }
        }
    }
    cout << fixed << setprecision(10);
    cout << ans << endl;
    return 0;
}

Compiler output:
a.cc: In function 'L bisect_line(P, P)':
a.cc:40:19: error: no match for 'operator*' (operand types are 'std::complex<long double>' and 'double')
   40 |     P mid = (a+b) *0.5;
      |             ~~~~~ ^~~~
      |               |    |
      |               |    double
      |               std::complex<long double>
In file included from a.cc:3:
/usr/include/c++/14/complex:400:5: note: candidate: 'template<class _Tp> std::complex<_Tp> std::operator*(const complex<_Tp>&, const complex<_Tp>&)'
  400 |     operator*(const complex<_Tp>& __x, const complex<_Tp>& __y)
      |     ^~~~~~~~
/usr/include/c++/14/complex:400:5: note:   template argument deduction/substitution failed:
a.cc:40:20: note:   mismatched types 'const std::complex<_Tp>' and 'double'
   40 |     P mid = (a+b) *0.5;
      |                    ^~~
/usr/include/c++/14/complex:409:5: note: candidate: 'template<class _Tp> std::complex<_Tp> std::operator*(const complex<_Tp>&, const _Tp&)'
  409 |     operator*(const complex<_Tp>& __x, const _Tp& __y)
      |     ^~~~~~~~
/usr/include/c++/14/complex:409:5: note:   template argument deduction/substitution failed:
a.cc:40:20: note:   deduced conflicting types for parameter 'const _Tp' ('long double' and 'double')
   40 |     P mid = (a+b) *0.5;
      |                    ^~~
/usr/include/c++/14/complex:418:5: note: candidate: 'template<class _Tp> std::complex<_Tp> std::operator*(const _Tp&, const complex<_Tp>&)'
  418 |     operator*(const _Tp& __x, const complex<_Tp>& __y)
      |     ^~~~~~~~
/usr/include/c++/14/complex:418:5: note:   template argument deduction/substitution failed:
a.cc:40:20: note:   mismatched types 'const std::complex<_Tp>' and 'double'
   40 |     P mid = (a+b) *0.5;
      |                    ^~~
a.cc: In function 'int main()':
a.cc:58:33: error: no match for 'operator*' (operand types are 'std::complex<long double>' and 'double')
   58 |             P mid = (p[i]+p[j]) *0.5;
      |                     ~~~~~~~~~~~ ^~~~
      |                          |       |
      |                          |       double
      |                          std::complex<long double>
/usr/include/c++/14/complex:400:5: note: candidate: 'template<class _Tp> std::complex<_Tp> std::operator*(const complex<_Tp>&, const complex<_Tp>&)'
  400 |     operator*(const complex<_Tp>& __x, const complex<_Tp>& __y)
      |     ^~~~~~~~
/usr/include/c++/14/complex:400:5: note:   template argument deduction/substitution failed:
a.cc:58:34: note:   mismatched types 'const std::complex<_Tp>' and 'double'
   58 |             P mid = (p[i]+p[j]) *0.5;
      |                                  ^~~
/usr/include/c++/14/complex:409:5: note: candidate: 'template<class _Tp> std::complex<_Tp> std::operator*(const complex<_Tp>&, const _Tp&)'
  409 |     operator*(const complex<_Tp>& __x, const _Tp& __y)
      |     ^~~~~~~~
/usr/include/c++/14/complex:409:5: note:   template argument deduction/substitution failed:
a.cc:58:34: note:   deduced conflicting types for parameter 'const _Tp' ('long double' and 'double')
   58 |             P mid = (p[i]+p[j]) *0.5;
      |                                  ^~~
/usr/include/c++/14/complex:418:5: note: candidate: 'template<class _Tp> std::complex<_Tp> std::operator*(const _Tp&, const complex<_Tp>&)'
  418 |     operator*(const _Tp& __x, const complex<_Tp>& __y)
      |     ^~~~~~~~
/usr/include/c++/14/complex:418:5: note:   template argument deduction/substitution failed:
a.cc:58:34: note:   mismatched types 'const std::complex<_Tp>' and 'double'
   58 |             P mid = (p[i]+p[j]) *0.5;
      |                                  ^~~