Language: C++

// #include<bits/stdc++.h>
// using namespace std;

// #define int long long
// #define endl "\n"
// #define REP(i,a,n) for(int i=a;i<n;++i)
// #define REPR(i,a,n) for(int i=a;i>n;--i)
// #define RUP(a,b) ((a+b-1)/(b))
// #define ALL(v) (v).begin(),(v).end()
// #define pb push_back
// #define mp make_pair
// #define mt make_tuple
// //#define MOD 1000000007
// #define INF LLONG_MAX/2

// typedef long long ll;
// typedef pair<int,int> Pii;
// typedef tuple<int,int,int> Tiii;
// typedef vector<int> Vi;
// typedef vector<Vi> VVi;
// typedef vector<Pii> VPii;
// typedef vector<string> Vs;

// template<class T> inline bool chmax(T& a,T b){if(a<b){a=b;return 1;}return 0;}
// template<class T> inline bool chmin(T& a,T b){if(a>b){a=b;return 1;}return 0;}
// template<class T> void YesNo(T a) {cout<<(a?"Yes":"No")<<endl;}
// template<class T> void YESNO(T a) {cout<<(a?"YES":"NO")<<endl;}
// void vin(Vi &v){REP(i,0,(v).size()) cin>>v[i];}
// void vin(Vi &v,Vi &v2){REP(i,0,(v).size()) cin>>v[i]>>v2[i];}
// void vout(Vi &v){for(int i=0;i<(v).size();i++) cout<<v[i]<<" ";cout<<endl;}
// int gcd(int a,int b){return b?gcd(b,a%b):a;}
// int lcm(int a,int b){return a/gcd(a,b)*b;}
// void uniq(Vi &v){sort(v.begin(),v.end()); v.erase(unique(v.begin(),v.end()),v.end());}
// int ctoi(char c){if(c>='0'&&c<='9'){return c-'0';}return 0;}
// void accum(Vi &v){REP(i,1,(v).size()) v[i]+=v[i-1];}
// bool comp(Pii a,Pii b){
//     if(a.second != b.second) return a.second<b.second;
//     else return a.first<b.first;
// }


// void solve(long long n, std::vector<long long> x, std::vector<long long> y){
//     REP(i,0,n){
//         REP(j,i+1,n){
//             REP(k,j+1,n){
//                 double a=x[i];double aa=a*a;
//                 double b=y[i];double bb=b*b;
//                 double c=x[j];double cc=c*c;
//                 double d=y[j];double dd=d*d;
//                 double e=x[k];double ee=e*e;
//                 double f=y[k];double ff=f*f;
                
//                 double px,py;
//                 py = ((e - a) * (aa + bb - cc - dd) - (c - a) * (aa + bb - ee- ff)) / (2 * (e - a)*(b - d) - 2 * (c - a) * (b - f));
//                 if(c==a) px = (2 * (b - d) * py - aa - bb + cc + dd) / (2 * (c - a));
//                 else px = (2 * (b - f) * py - aa - bb + ee + ff) / (2 * (e - a));
//                 cout<<px<<" "<<py<<endl;
//             }
//         }
//     }
// }

// // Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools  (tips: You use the default template now. You can remove this line by using your custom template)
// signed main(){
//     long long N;
//     scanf("%lld",&N);
//     std::vector<long long> x(N);
//     std::vector<long long> y(N);
//     for(int i = 0 ; i < N ; i++){
//         scanf("%lld",&x[i]);
//         scanf("%lld",&y[i]);
//     }
//     solve(N, std::move(x), std::move(y));
//     return 0;
// }

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i,n) for(int i = 0; i < (int)(n); i++)
#define all(c) begin(c), end(c)
#define dump(x) cerr << __LINE__ << ":\t" #x " = " << x << endl

using ld = double;
using P = complex<ld>;
using G = vector<P>;
const ld pi = 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(); }

using C = pair<ld, P>;
#define rad first
#define pnt second

C smallest_enclosing_disc(vector<P> ps){
    auto c3 = [](const P &a, const P &b, const P &c){
        ld A = norm(b - c);
        ld B = norm(c - a);
        ld C = norm(a - b);
        ld S = abs(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 r = abs(p - a);
        return make_pair(r, p);
    };

    auto c2 = [](const P &a, const P &b){
        P c = (a + b) / (ld)2;
        ld r = abs(a - c);
        return make_pair(r, c);
    };

    auto in_circle = [](const P &a, const C &c){
        return norm(a - c.pnt) <= c.rad*c.rad + eps;
    };

    int n = ps.size();
    random_shuffle(ps.begin(), ps.end());
    C c = c2(ps[0], ps[1]);
    for(int i = 2; i < n; ++i){
        if(!in_circle(ps[i], c)){
            c = c2(ps[0], ps[i]);
            for(int j = 1; j < i; ++j){
                if(!in_circle(ps[j], c)){
                    c = c2(ps[j], ps[i]);
                    for(int k = 0; k < j; ++k){
                        if(!in_circle(ps[k], c)){
                            c = c3(ps[i], ps[j], ps[k]);
                        }
                    }
                }
            }
        }
    }
    return c;
}

http://www.spoj.com/problems/QCJ4/
http://www.spoj.com/status/ns=18116289

int main(){
    srand(time(0));
    int n;
    cin >> n;
    vector<P> ps(n);
    for(int i = 0; i < n; ++i){
        ld x,y;
        cin >> x >> y;
        ps[i] = P(x,y);
    }

    printf("%.2lf\n", (double)smallest_enclosing_disc(ps).rad);
}


int n,m;
ld r[111], mb[111];
 
bool used[111];

bool chk(int s){
    vector<int> b;
    rep(i,n)if(!used[i]) b.emplace_back(r[i]);
    vector<ld> a;
    for(int i = s; i < m; ++i) a.emplace_back(mb[i]);
    sort(all(a));
    sort(all(b));
    int last = -1;
    rep(i,a.size()){
        bool found = false;
        for(int j = last+1; j < (int)b.size(); ++j){
            if(a[i] < b[j] + eps){
                found = true;
                last = j;
                break;
            }
        }
        if(!found)return false;
    }
    return true;
}

// int main(){
//     vector<int> ans;
//     cin >> n >> m;
//     rep(i,n) cin >> r[i];
//     rep(i,m){
//         int k; cin >> k;
//         G g(k);
//         rep(j,k){
//             ld x,y;
//             cin >> x >> y;
//             g[j] = P(x,y);
//         }
//         mb[i] = smallest_enclosing_disc(g).rad;
//     }
 
//     rep(i,m) used[i] = false;
//     bool f = true;
//     rep(i,m){
//         bool found = false;
//         rep(j,n){
//             if(used[j]) continue;
//             if(!(mb[i] < r[j] + eps)) continue;
//             used[j] = true;
//             if(chk(i+1)){
//                 ans.push_back(j);
//                 found = true;
//                 break;
//             }
//             used[j] = false;
//         }
//         if(!found){
//             f = false; break;
//         }
//     }
//     if(f){
//         rep(i,m) cout << ans[i]+1 << "\n";
//     } else {
//         cout << "NG" << endl;
//     }
// }

Compiler output:
a.cc: In function 'C smallest_enclosing_disc(std::vector<std::complex<double> >)':
a.cc:120:19: warning: 'void std::random_shuffle(_RAIter, _RAIter) [with _RAIter = __gnu_cxx::__normal_iterator<complex<double>*, vector<complex<double> > >]' is deprecated: use 'std::shuffle' instead [-Wdeprecated-declarations]
  120 |     random_shuffle(ps.begin(), ps.end());
      |     ~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~
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:77:
/usr/include/c++/14/bits/stl_algo.h:4492:5: note: declared here
 4492 |     random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last)
      |     ^~~~~~~~~~~~~~
a.cc: At global scope:
a.cc:140:5: error: found ':' in nested-name-specifier, expected '::'
  140 | http://www.spoj.com/problems/QCJ4/
      |     ^
      |     ::
a.cc:140:1: error: 'http' does not name a type
  140 | http://www.spoj.com/problems/QCJ4/
      | ^~~~