Language: C++

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

template<class T>
bool chmax(T& a, const T& b) {
    if (a < b) { a = b; return true; }
    return false;
}
template<class T>
bool chmin(T& a, const T& b) {
    if (b < a) { a = b; return true; }
    return false;
}

// std::vector Declaration
template<typename T>
vector<T> make_v(size_t a) { return vector<T>(a); }
template<typename T, typename... Ts>
auto make_v(size_t a, Ts... ts) {
    return vector<decltype(make_v<T>(ts...))>(a, make_v<T>(ts...));
}

// std::vector Declaration and Initialization
template<typename T>
vector<T> make_vector(size_t a, T x) { return vector<T>(a, x); }
template<typename T, typename U, typename... Ts>
auto make_vector(size_t a, U b, Ts... ts) {
    return vector<decltype(make_vector<T>(b,ts...))>(a, make_vector<T>(b, ts...));
}

// std::vector Input
template<typename T>
istream& operator>>(istream& is, vector<T>& v) {
    for (auto &e : v) is >> e;
    return is;
}

// std::vector Debug
template<typename T>
ostream& operator<<(ostream& os, const vector<T>& v) {
    os << "[";
    bool a = 1;
    for (auto e : v) {
        os << (a ? "" : " ");
        os << e;
        a = 0;
    }
    os << "]";
    return os;
}

// std::array Debug
template<typename T, size_t n>
ostream& operator<<(ostream& os, const array<T, n>& v) {
    os << "[";
    bool a = 1;
    for (auto e : v) {
        os << (a ? "" : " ");
        os << e;
        a = 0;
    }
    os << "]";
    return os;
}

// std::deque Debug
template<typename T>
ostream& operator<<(ostream& os, const deque<T>& d) {
    os << "[";
    bool a = 1;
    for (auto e : d) {
        os << (a ? "" : " ");
        os << e;
        a = 0;
    }
    os << "]";
    return os;
}

// std::pair Debug
template<typename T, typename U>
ostream& operator<<(ostream& os, const pair<T, U>& p) {
    os << "(" << p.first << " " << p.second << ")";
    return os;
}

// std::set Debug
template<typename T>
ostream& operator<<(ostream& os, const set<T>& st) {
    os << "{";
    bool a = 1;
    for (auto e : st) {
        os << (a ? "" : " ");
        os << e;
        a = 0;
    }
    os << "}";
    return os;
}

// std::multiset Debug
template<typename T>
ostream& operator<<(ostream& os, const multiset<T>& st) {
    os << "{";
    bool a = 1;
    for (auto e : st) {
        os << (a ? "" : " ");
        os << e;
        a = 0;
    }
    os << "}";
    return os;
}

// std::map Debug
template<typename T, typename U>
ostream& operator<<(ostream& os, const map<T, U>& mp) {
    os << "{";
    bool a = 1;
    for (auto e : mp) {
        os << (a ? "" : " ");
        os << e.first << ":" << e.second;
        a = 0;
    }
    os << "}";
    return os;
}

// std::tuple Debug
template<int N, class Tuple>
void out(ostream& os, const Tuple& t){}
template<int N, class Tuple, class H, class ...Ts>
void out(ostream& os, const Tuple& t) {
    if (N) os << " ";
    os << get<N>(t);
    out<N+1,Tuple,Ts...>(os, t);
}
template<class ...Ts>
ostream& operator<<(ostream& os, const tuple<Ts...>& t) {
    os << "(";
    out<0,tuple<Ts...>,Ts...>(os, t);
    os << ")";
    return os;
}

// Debug
#define DUMP(x) cerr<<#x<<" = "<<(x)<<endl

// Weighted edge
template<typename T>
struct edge {
    int src, to;
    T cost;

    edge(int to, T cost) : src(-1), to(to), cost(cost) {}
    edge(int src, int to, T cost) : src(src), to(to), cost(cost) {}

    friend ostream& operator<<(ostream& os, const edge& e) {
        return os << "(" << e.src << "->" << e.to << ":" << e.cost << ")";
    }
};

using LL = long long;
using LD = long double;

#define fs first
#define sc second

const LL MOD = 1e9+7;

const LD EPS = 1e-9;

using Point = complex<LD>;

int main()
{
    cin.tie(0);
    ios::sync_with_stdio(false);
    cout << fixed << setprecision(10);

    int N, K; cin >> N >> K;

    vector<LD> c(N);
    vector<Point> p(N);

    for (int i = 0; i < N; ++i) {
        LD x, y;
        cin >> x >> y >> c[i];
        p[i] = {x, y};
    }

    auto check = [&](LD t) {
        for (int i = 0; i < N; ++i) {
            for (int j = i+1; j < N; ++j) {
                LD ri = t / c[i],
                       rj = t / c[j];

                LD d = abs(p[i] - p[j]);

                LD xi = p[i].real(), yi = p[i].imag(),
                       xj = p[j].real(), yj = p[j].imag();

                vector<Point> qs;
                if (ri + rj >= d) {
                    LD A = -2*xi +2*xj,
                           B = -2*yi +2*yj,
                           C = (xi*xi + yi*yi - ri*ri) -
                               (xj*xj + yj*yj - rj*rj);
                    //DUMP(A);
                    //DUMP(B);
                    //DUMP(C);

                    LD di = abs(A*xi + B*yi + C) / sqrt(A*A + B*B);
                    //DUMP(di);

                    LD h = sqrt(ri*ri - di*di);
                    //DUMP(h);

                    Point n = (p[j]-p[i]) / abs(p[j]-p[i]);
                    qs.push_back(p[i] + di * n + h * polar(1.0, M_PI/2) * n);
                    qs.push_back(p[i] + di * n + h * polar(1.0,-M_PI/2) * n);
                }
                else {
                    qs.push_back(p[i]);
                    qs.push_back(p[j]);
                }

                for (Point& q : qs) {
                    int count = 0;
                    for (int k = 0; k < N; ++k) {
                        if (abs(p[k] - q) - t/c[k] < EPS) {
                            ++count;
                        }
                    }
                    if (count >= K) {
                        return true;
                    }
                }

            }
        }
        return false;
    };

    LD ng = 0, ok = 1e6;
    while (abs(ok - ng) > EPS) {
        LD mid = (ng + ok) / 2;
        (check(mid) ? ok : ng) = mid;
    }

    cout << ok << endl;


    return 0;
}


Compiler output:
a.cc: In lambda function:
a.cc:220:52: error: no match for 'operator*' (operand types are 'LD' {aka 'long double'} and 'std::complex<double>')
  220 |                     qs.push_back(p[i] + di * n + h * polar(1.0, M_PI/2) * n);
      |                                                  ~ ^ ~~~~~~~~~~~~~~~~~~
      |                                                  |        |
      |                                                  |        std::complex<double>
      |                                                  LD {aka long 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:220:71: note:   mismatched types 'const std::complex<_Tp>' and 'LD' {aka 'long double'}
  220 |                     qs.push_back(p[i] + di * n + h * polar(1.0, M_PI/2) * n);
      |                                                                       ^
/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:220:71: note:   mismatched types 'const std::complex<_Tp>' and 'LD' {aka 'long double'}
  220 |                     qs.push_back(p[i] + di * n + h * polar(1.0, M_PI/2) * n);
      |                                                                       ^
/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:220:71: note:   deduced conflicting types for parameter '_Tp' ('long double' and 'double')
  220 |                     qs.push_back(p[i] + di * n + h * polar(1.0, M_PI/2) * n);
      |                                                                       ^
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:220:71: note:   mismatched types 'const std::_Expr<_Dom1, typename _Dom1::value_type>' and 'LD' {aka 'long double'}
  220 |                     qs.push_back(p[i] + di * n + h * polar(1.0, M_PI/2) * n);
      |                                                                       ^
/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:220:71: note:   mismatched types 'const std::_Expr<_Dom1, typename _Dom1::value_type>' and 'LD' {aka 'long double'}
  220 |                     qs.push_back(p[i] + di * n + h * polar(1.0, M_PI/2) * n);
      |                                                                       ^
/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:220:71: note:   'std::complex<double>' is not derived from 'const std::_Expr<_Dom1, typename _Dom1::value_type>'
  220 |                     qs.push_back(p[i] + di * n + h * polar(1.0, M_PI/2) * n);
      |                                                                       ^
/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:220:71: note:   mismatched types 'const std::_Expr<_Dom1, typename _Dom1::value_type>' and 'LD' {aka 'long double'}
  220 |                     qs.push_back(p[i] + di * n + h * polar(1.0, M_PI/2) * n);
      |                                                                       ^
/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:220:71: note:   'std::complex<double>' is not derived from 'const std::_Expr<_Dom1, typename _Dom1::value_type>'
  220 |                     qs.push_back(p[i] + di * n + h * polar(1.0, M_PI/2) * n);
      |                                                                       ^
/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:220:71: note:   mismatched types 'const std::valarray<_Tp>' and 'LD' {aka 'long double'}
  220 |                     qs.push_back(p[i] + di * n + h * polar(1.0, M_PI/2) * n);
      |                                                                       ^
/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:220:71: note:   mismatched types 'const std::valarray<_Tp>' and 'LD' {aka 'long double'}
  220 |                     qs.push_back(p[i] + di * n + h * polar(1.0, M_PI/2) * n);
      |                                                                       ^
/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:220:71: note:   'std::complex<double>' is not derived from 'const std::valarray<_Tp>'
  220 |                     qs.push_back(p[i] + di * n + h * polar(1.0, M_PI/2) * n);
      |                                                                       ^
a.cc:221:52: error: no match for 'operator*' (operand types are 'LD' {aka 'long double'} and 'std::complex<double>')
  221 |                     qs.push_back(p[i] + di * n + h * polar(1.0,-M_PI/2) * n);
      |                                                  ~ ^ ~~~~~~~~~~~~~~~~~~
      |                                                  |        |
      |                                                  |        std::complex<double>
      |                                                  LD {aka 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:221:71: note:   mismatched types 'const std::complex<_Tp>' and 'LD' {aka 'long double'}
  221 |                     qs.push_bac