Language: C++

#include<bits/stdc++.h>
//using namespace std;
#define rep(i,j,n) for(ll i=(ll)(j);i<(ll)(n);i++)
#define REP(i,j,n) for(ll i=(ll)(j);i<=(ll)(n);i++)
#define per(i,j,n) for(ll i=(ll)(j);(ll)(n)<=i;i--)
#define ll double
#define int double
#define ALL(a) (a).begin(),(a).end()
#define disup(A,key) distance(A.begin(),upper_bound(ALL(A),(ll)(key)))
#define dislow(A,key) distance(A.begin(),lower_bound(ALL(A),(ll)(key)))
#define pb push_back
#define mp std::make_pair
#define endl "\n"
using std::cin;
using std::cout;
using std::vector;
using std::string;
using std::upper_bound;
using std::lower_bound;
using vi=vector<ll>;
using vii=vector<vi>;
using pii=std::pair<ll,ll>;
const ll MOD=1e9+7;
//const ll MOD=998244353;
const ll MAX=500000;
const ll INF=(1ll<<62)-1;
template<class T>
class prique :public std::priority_queue<T, std::vector<T>, std::greater<T>> {};
struct Binary_indexed_tree{
    int N;
    vi bit;
    Binary_indexed_tree(int n):N(n){
        bit.resize(N+1,0);
    }
    void add(int x,int a){
        for(x;x<=N;x+=(x&-x)) bit[x]+=a;
    }
    ll sum(int x){
        ll ret=0;
        for(x;x>0;x-=(x&-x)) ret+=bit[x];
        return ret;
    }
};
ll modpow(ll X,ll Y){
    ll sum=X,cnt=1;
    vi A;
    while(cnt<=Y){
        A.pb(sum);
        sum*=sum;
        sum%=MOD;
        cnt*=2;
    }
    int M=A.size();
    ll ret=1;
    REP(i,1,M){
        if(Y>=(1ll<<M-i)){
            Y-=(1ll<<M-i);
            ret*=A[M-i];
            ret%=MOD;
        }
    }
    return ret;
}
ll fac[MAX],finv[MAX],inv[MAX];
void COMinit(){
    fac[0]=fac[1]=finv[1]=finv[0]=inv[0]=inv[1]=1;
    rep(i,2,MAX){
        fac[i]=fac[i-1]*i%MOD;
        inv[i]=modpow(i,MOD-2);
        finv[i]=finv[i-1]*inv[i]%MOD;
    }
}
ll COM(ll n,ll r){
    if(n<r||n<0||r<0) return 0;
    return fac[n]*finv[r]%MOD*finv[n-r]%MOD;
}
std::pair<double,double> func(int A,int B,int C,int D,int E,int F){
    ll G=C-A,H=D-B,I=E-A,J=F-B;
    if(G*J==H*I) return mp(INF,INF);
    double K=(C+A)/2.0*G*1.0+(D+B)/2.0*H*1.0,L=(E+A)/2.0*I*1.0+(F+B)/2.0*J*1.0;
    if(G==0||I==0){
        if(I==0) std::swap(G,I),std::swap(H,J),std::swap(K,L);
        double Y=K/H,X=(L-J*Y)/I;
        return mp(X,Y);
    }
    ll p=G*I/std::__gcd(G,I);
    G*=p/G,H*=p/G,K*=p/G,I*=p/I,J*=p/I,L*=p/I;
    double Y=(K-L)*1.0/(H-J),X=(K-H*Y)*1.0/G;
    return mp(X,Y);
}
signed main(){
    int N; cin>>N;
    vi A(N),B(N);
    rep(i,0,N) cin>>A[i]>>B[i];
    double ans=MOD;
    rep(i,0,N-1){
        rep(j,i+1,N){
            double X=(A[i]+A[j])/2.0,Y=(B[i]+B[j])/2.0;
            double max=0;
            rep(k,0,N){
                double P=A[k]-X,Q=B[k]-Y;
                max=std::max(max,P*P+Q*Q);
            }
            ans=std::min(ans,sqrt(max));
        }
    }
    rep(i,0,N-2){
        rep(j,i+1,N-1){
            rep(k,j+1,N){
                int C=A[j]-A[i],D=B[j]-B[i],E=A[k]-A[i],F=B[k]-B[i];
                int S=abs(C*F-D*E);
                if(S==0) continue;
                std::pair<double,double> p=func(A[i],B[i],A[j],B[j],A[k],B[k]);
                if(p.first>=MOD) continue;
                double X=p.first,Y=p.second;
                double max=0;
            	rep(k,0,N){
                	double P=A[k]-X,Q=B[k]-Y;
                	max=std::max(max,P*P+Q*Q);
            	}
            	ans=std::min(ans,sqrt(max));
            }
        }
    }
    printf("%.10lf\n",ans);
}


Compiler output:
a.cc: In member function 'void Binary_indexed_tree::add(double, double)':
a.cc:36:25: error: invalid operands of types 'double' and 'double' to binary 'operator&'
   36 |         for(x;x<=N;x+=(x&-x)) bit[x]+=a;
      |                        ~^~~
      |                        | |
      |                        | double
      |                        double
a.cc: In member function 'double Binary_indexed_tree::sum(double)':
a.cc:40:24: error: invalid operands of types 'double' and 'double' to binary 'operator&'
   40 |         for(x;x>0;x-=(x&-x)) ret+=bit[x];
      |                       ~^~~
      |                       | |
      |                       | double
      |                       double
a.cc: In function 'double modpow(double, double)':
a.cc:50:12: error: invalid operands of types 'double' and 'double' to binary 'operator%'
   50 |         sum%=MOD;
      |         ~~~^~~~~
a.cc:50:12: note:   in evaluation of 'operator%=(double, double)'
a.cc:56:19: error: invalid operands of types 'long long int' and 'double' to binary 'operator<<'
   56 |         if(Y>=(1ll<<M-i)){
      |                ~~~^~~~~
      |                |     |
      |                |     double
      |                long long int
a.cc:57:20: error: invalid operands of types 'long long int' and 'double' to binary 'operator<<'
   57 |             Y-=(1ll<<M-i);
      |                 ~~~^~~~~
      |                 |     |
      |                 |     double
      |                 long long int
a.cc:59:16: error: invalid operands of types 'double' and 'double' to binary 'operator%'
   59 |             ret%=MOD;
      |             ~~~^~~~~
a.cc:59:16: note:   in evaluation of 'operator%=(double, double)'
a.cc: At global scope:
a.cc:64:8: error: conversion from 'double' to 'long unsigned int' in a converted constant expression
   64 | ll fac[MAX],finv[MAX],inv[MAX];
      |        ^~~
a.cc:64:8: error: could not convert 'MAX' from 'const double' to 'long unsigned int'
   64 | ll fac[MAX],finv[MAX],inv[MAX];
      |        ^~~
      |        |
      |        const double
a.cc:64:8: error: size of array 'fac' has non-integral type 'const double'
a.cc:64:18: error: conversion from 'double' to 'long unsigned int' in a converted constant expression
   64 | ll fac[MAX],finv[MAX],inv[MAX];
      |                  ^~~
a.cc:64:18: error: could not convert 'MAX' from 'const double' to 'long unsigned int'
   64 | ll fac[MAX],finv[MAX],inv[MAX];
      |                  ^~~
      |                  |
      |                  const double
a.cc:64:18: error: size of array 'finv' has non-integral type 'const double'
a.cc:64:27: error: conversion from 'double' to 'long unsigned int' in a converted constant expression
   64 | ll fac[MAX],finv[MAX],inv[MAX];
      |                           ^~~
a.cc:64:27: error: could not convert 'MAX' from 'const double' to 'long unsigned int'
   64 | ll fac[MAX],finv[MAX],inv[MAX];
      |                           ^~~
      |                           |
      |                           const double
a.cc:64:27: error: size of array 'inv' has non-integral type 'const double'
a.cc: In function 'void COMinit()':
a.cc:68:12: error: invalid types 'double [1][double]' for array subscript
   68 |         fac[i]=fac[i-1]*i%MOD;
      |            ^
a.cc:68:19: error: invalid types 'double [1][double]' for array subscript
   68 |         fac[i]=fac[i-1]*i%MOD;
      |                   ^
a.cc:69:12: error: invalid types 'double [1][double]' for array subscript
   69 |         inv[i]=modpow(i,MOD-2);
      |            ^
a.cc:70:13: error: invalid types 'double [1][double]' for array subscript
   70 |         finv[i]=finv[i-1]*inv[i]%MOD;
      |             ^
a.cc:70:21: error: invalid types 'double [1][double]' for array subscript
   70 |         finv[i]=finv[i-1]*inv[i]%MOD;
      |                     ^
a.cc:70:30: error: invalid types 'double [1][double]' for array subscript
   70 |         finv[i]=finv[i-1]*inv[i]%MOD;
      |                              ^
a.cc: In function 'double COM(double, double)':
a.cc:75:15: error: invalid types 'double [1][double]' for array subscript
   75 |     return fac[n]*finv[r]%MOD*finv[n-r]%MOD;
      |               ^
a.cc:75:23: error: invalid types 'double [1][double]' for array subscript
   75 |     return fac[n]*finv[r]%MOD*finv[n-r]%MOD;
      |                       ^
a.cc:75:35: error: invalid types 'double [1][double]' for array subscript
   75 |     return fac[n]*finv[r]%MOD*finv[n-r]%MOD;
      |                                   ^
In file included from /usr/include/c++/14/algorithm:61,
                 from /usr/include/x86_64-linux-gnu/c++/14/bits/stdc++.h:51,
                 from a.cc:1:
/usr/include/c++/14/bits/stl_algo.h: In instantiation of '_EuclideanRingElement std::__gcd(_EuclideanRingElement, _EuclideanRingElement) [with _EuclideanRingElement = double]':
a.cc:86:24:   required from here
   86 |     ll p=G*I/std::__gcd(G,I);
      |              ~~~~~~~~~~^~~~~
/usr/include/c++/14/bits/stl_algo.h:1141:43: error: invalid operands of types 'double' and 'double' to binary 'operator%'
 1141 |           _EuclideanRingElement __t = __m % __n;
      |                                       ~~~~^~~~~