Language: C++

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

int64_t n, k;
int64_t x[60], y[60], c[60];
double t;

using pt = pair<double, double>;

double dist(pt p1, pt p2){
    return sqrt( (p1.first-p2.first)*(p1.first-p2.first) + (p1.second-p2.second)*(p1.second-p2.second) );
}

pair<bool, pair<pt, pt>> getpt(int i, int j){
    double r1 = t / c[i];
    double r2 = t / c[j];
    double d = dist({x[i], y[i]}, {x[j], y[j]});
    double d1 = (d * d + r1 * r1 - r2 * r2) / (2.0 * d);
    double d2 = (d * d - r1 * r1 + r2 * r2) / (2.0 * d);
    double xx = r1 * r1 - d1 * d1;
    pt rr = { (x[i] - x[j]) / d, (y[i] - y[j]) / d };
    pt v  = { (y[i] - y[j]) / d,-(x[i] - x[j]) / d };
    pt ret1 = pt{ x[j], y[j] } + rr * d2;
    if(xx < 0){
        return {false, {ret1, ret1}};
    }
    pt ret2 = v * sqrt(xx);
    return {true, {ret1, ret2}};
}

bool check(pt point){
    int cnt = 0;
    for(int i=0;i<n;++i){
        if(c[i] * dist({x[i], y[i]}, point) <= t){
            ++cnt;
            if(cnt >= k) return true;
        }
    }
    return false;
}

pt operator+(pt lhs, pt rhs){ return {lhs.first + rhs.first, lhs.second + rhs.second}; }
pt operator-(pt lhs, pt rhs){ return {lhs.first - rhs.first, lhs.second - rhs.second}; }
pt operator*(pt lhs, double rhs){ return {lhs.first * rhs, lhs.second * rhs}; }

int main(){
    cout.precision(12);
    cout.setf(ios_base::fixed, ios_base::floatfield);

    cin >> n >> k;
    for(int i=0;i<n;++i){
        cin >> x[i] >> y[i] >> c[i];
    }
    double eps = 1e-12;
    double ok = 2e5, ng = 0;
    while(ok - ng > eps && (ok - ng) > eps * ok){
        t = (ok + ng) * 0.5;
        vector<pt> cand;

        for(int i=0;i<n;++i){
            for(int j=0;j<n;++j){
                auto p = getpt(i, j);
                if(p.first){
                    cand.emplace_back(p.second.first);
                    cand.emplace_back(p.second.first + p.second.second);
                    cand.emplace_back(p.second.first - p.second.second);
                    cand.emplace_back(p.second.first + p.second.second * 0.99);
                    cand.emplace_back(p.second.first - p.second.second * 0.99);
                    cand.emplace_back(x[i], y[i]);
                    cand.emplace_back(x[j], y[j]);
                }else if(p.second.first.first > 0){
                    cand.emplace_back(p.second.first);
                    cand.emplace_back(x[i], y[i]);
                    cand.emplace_back(x[j], y[j]);
                }
            }
        }
        for(auto point: cand){
            if(check(point)) goto l_ok;
        }
        ng = t;
        continue;
        l_ok:
        ok = t;
    }
    cout << ok << endl;

    return 0;
}

Compiler output:
a.cc: In function 'std::pair<bool, std::pair<std::pair<double, double>, std::pair<double, double> > > getpt(int, int)':
a.cc:23:37: error: no match for 'operator*' (operand types are 'pt' {aka 'std::pair<double, double>'} and 'double')
   23 |     pt ret1 = pt{ x[j], y[j] } + rr * d2;
      |                                  ~~ ^ ~~
      |                                  |    |
      |                                  |    double
      |                                  pt {aka std::pair<double, double>}
In file included from /usr/include/c++/14/ccomplex:39,
                 from /usr/include/x86_64-linux-gnu/c++/14/bits/stdc++.h:127,
                 from a.cc:1:
/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:23:39: note:   'pt' {aka 'std::pair<double, double>'} is not derived from 'const std::complex<_Tp>'
   23 |     pt ret1 = pt{ x[j], y[j] } + rr * d2;
      |                                       ^~
/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:23:39: note:   'pt' {aka 'std::pair<double, double>'} is not derived from 'const std::complex<_Tp>'
   23 |     pt ret1 = pt{ x[j], y[j] } + rr * d2;
      |                                       ^~
/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:23:39: note:   mismatched types 'const std::complex<_Tp>' and 'double'
   23 |     pt ret1 = pt{ x[j], y[j] } + rr * d2;
      |                                       ^~
In file included from /usr/include/c++/14/valarray:605,
                 from /usr/include/x86_64-linux-gnu/c++/14/bits/stdc++.h:166:
/usr/include/c++/14/bits/valarray_after.h:407:5: note: candidate: 'template<class _Dom1, class _Dom2> std::_Expr<std::__detail::_BinClos<std::__multiplies, std::_Expr, std::_Expr, _Dom1, _Dom2>, typename std::__fun<std::__multiplies, typename _Dom1::value_type>::result_type> std::operator*(const _Expr<_Dom1, typename _Dom1::value_type>&, const _Expr<_Dom2, typename _Dom2::value_type>&)'
  407 |     _DEFINE_EXPR_BINARY_OPERATOR(*, struct std::__multiplies)
      |     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/valarray_after.h:407:5: note:   template argument deduction/substitution failed:
a.cc:23:39: note:   'pt' {aka 'std::pair<double, double>'} is not derived from 'const std::_Expr<_Dom1, typename _Dom1::value_type>'
   23 |     pt ret1 = pt{ x[j], y[j] } + rr * d2;
      |                                       ^~
/usr/include/c++/14/bits/valarray_after.h:407:5: note: candidate: 'template<class _Dom> std::_Expr<std::__detail::_BinClos<std::__multiplies, std::_Expr, std::_Constant, _Dom, typename _Dom::value_type>, typename std::__fun<std::__multiplies, typename _Dom1::value_type>::result_type> std::operator*(const _Expr<_Dom1, typename _Dom1::value_type>&, const typename _Dom::value_type&)'
  407 |     _DEFINE_EXPR_BINARY_OPERATOR(*, struct std::__multiplies)
      |     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/valarray_after.h:407:5: note:   template argument deduction/substitution failed:
a.cc:23:39: note:   'pt' {aka 'std::pair<double, double>'} is not derived from 'const std::_Expr<_Dom1, typename _Dom1::value_type>'
   23 |     pt ret1 = pt{ x[j], y[j] } + rr * d2;
      |                                       ^~
/usr/include/c++/14/bits/valarray_after.h:407:5: note: candidate: 'template<class _Dom> std::_Expr<std::__detail::_BinClos<std::__multiplies, std::_Constant, std::_Expr, typename _Dom::value_type, _Dom>, typename std::__fun<std::__multiplies, typename _Dom1::value_type>::result_type> std::operator*(const typename _Dom::value_type&, const _Expr<_Dom1, typename _Dom1::value_type>&)'
  407 |     _DEFINE_EXPR_BINARY_OPERATOR(*, struct std::__multiplies)
      |     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/valarray_after.h:407:5: note:   template argument deduction/substitution failed:
a.cc:23:39: note:   mismatched types 'const std::_Expr<_Dom1, typename _Dom1::value_type>' and 'double'
   23 |     pt ret1 = pt{ x[j], y[j] } + rr * d2;
      |                                       ^~
/usr/include/c++/14/bits/valarray_after.h:407:5: note: candidate: 'template<class _Dom> std::_Expr<std::__detail::_BinClos<std::__multiplies, std::_Expr, std::_ValArray, _Dom, typename _Dom::value_type>, typename std::__fun<std::__multiplies, typename _Dom1::value_type>::result_type> std::operator*(const _Expr<_Dom1, typename _Dom1::value_type>&, const valarray<typename _Dom::value_type>&)'
  407 |     _DEFINE_EXPR_BINARY_OPERATOR(*, struct std::__multiplies)
      |     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/valarray_after.h:407:5: note:   template argument deduction/substitution failed:
a.cc:23:39: note:   'pt' {aka 'std::pair<double, double>'} is not derived from 'const std::_Expr<_Dom1, typename _Dom1::value_type>'
   23 |     pt ret1 = pt{ x[j], y[j] } + rr * d2;
      |                                       ^~
/usr/include/c++/14/bits/valarray_after.h:407:5: note: candidate: 'template<class _Dom> std::_Expr<std::__detail::_BinClos<std::__multiplies, std::_ValArray, std::_Expr, typename _Dom::value_type, _Dom>, typename std::__fun<std::__multiplies, typename _Dom1::value_type>::result_type> std::operator*(const valarray<typename _Dom::value_type>&, const _Expr<_Dom1, typename _Dom1::value_type>&)'
  407 |     _DEFINE_EXPR_BINARY_OPERATOR(*, struct std::__multiplies)
      |     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/valarray_after.h:407:5: note:   template argument deduction/substitution failed:
a.cc:23:39: note:   mismatched types 'const std::_Expr<_Dom1, typename _Dom1::value_type>' and 'double'
   23 |     pt ret1 = pt{ x[j], y[j] } + rr * d2;
      |                                       ^~
/usr/include/c++/14/valarray:1198:1: note: candidate: 'template<class _Tp> std::_Expr<std::__detail::_BinClos<std::__multiplies, std::_ValArray, std::_ValArray, _Tp, _Tp>, typename std::__fun<std::__multiplies, _Tp>::result_type> std::operator*(const valarray<_Tp>&, const valarray<_Tp>&)'
 1198 | _DEFINE_BINARY_OPERATOR(*, __multiplies)
      | ^~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/valarray:1198:1: note:   template argument deduction/substitution failed:
a.cc:23:39: note:   'pt' {aka 'std::pair<double, double>'} is not derived from 'const std::valarray<_Tp>'
   23 |     pt ret1 = pt{ x[j], y[j] } + rr * d2;
      |                                       ^~
/usr/include/c++/14/valarray:1198:1: note: candidate: 'template<class _Tp> std::_Expr<std::__detail::_BinClos<std::__multiplies, std::_ValArray, std::_Constant, _Tp, _Tp>, typename std::__fun<std::__multiplies, _Tp>::result_type> std::operator*(const valarray<_Tp>&, const typename valarray<_Tp>::value_type&)'
 1198 | _DEFINE_BINARY_OPERATOR(*, __multiplies)
      | ^~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/valarray:1198:1: note:   template argument deduction/substitution failed:
a.cc:23:39: note:   'pt' {aka 'std::pair<double, double>'} is not derived from 'const std::valarray<_Tp>'
   23 |     pt ret1 = pt{ x[j], y[j] } + rr * d2;
      |                                       ^~
/usr/include/c++/14/valarray:1198:1: note: candidate: 'template<class _Tp> std::_Expr<std::__detail::_BinClos<std::__multiplies, std::_Constant, std::_ValArray, _Tp, _Tp>, typename std::__fun<std::__multiplies, _Tp>::result_type> std::operator*(const typename valarray<_Tp>::value_type&, const valarray<_Tp>&)'
 1198 | _DEFINE_BINARY_OPERATOR(*, __multiplies)
      | ^~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/valarray:1198:1: note:   template argument deduction/substitution failed:
a.cc:23:39: note:   mismatched types 'const std::valarray<_Tp>' and 'double'
   23 |     pt ret1 = pt{ x[j], y[j] } + rr * d2;
      |                                       ^~
a.cc:27:17: error: no match for 'operator*' (operand types are 'pt' {aka 'std::pair<double, double>'} and 'double')
   27 |     pt ret2 = v * sqrt(xx);
      |               ~ ^ ~~~~~~~~
      |               |       |
      |               |       double
      |               pt {aka std::pair<double, 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:27:26: note:   'pt' {aka 'std::pair<double, double>'} is not derived from 'const std::complex<_Tp>'
   27 |     pt ret2 = v * sqrt(xx);
      |                          ^
/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:27:26: note:   'pt' {aka 'std::pair<double, double>'} is not derived from 'const std::complex<_Tp>'
   27 |     pt ret2 = v * sqrt(xx);
      |                          ^
/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:27:26: note:   mismatched types 'const std::complex<_Tp>' and 'double'
   27 |     pt ret2