// Original C++ solution (slower):
#include <bits/stdc++.h>

using namespace std;



using Real = long double;

using Point = complex< Real >;

const Real EPS = 1e-12, PI = acos(-1.0L);



inline bool eq(Real a, Real b) { return fabs(b - a) < EPS; }



istream &operator>>(istream &is, Point &p) {

  Real a, b;

  is >> a >> b;

  p = Point(a, b);

  return is;

}





struct Circle {

  Point p;

  Real r;



  Circle() = default;



  Circle(Point p, Real r) : p(p), r(r) {}

};



using Points = vector< Point >;

using Circles = vector< Circle >;



int checker(Circle c1, Circle c2) {

  if(c1.r < c2.r) swap(c1, c2);

  Real d = abs(c1.p - c2.p);

  if(c1.r + c2.r < d) return 4;

  if(eq(c1.r + c2.r, d)) return 3;

  if(c1.r - c2.r < d) return 2;

  if(eq(c1.r - c2.r, d)) return 1;

  return 0;

}



bool intersect(Circle c1, Circle c2) {

    int tmp = checker(c1, c2);

    return 1 <= tmp and tmp <= 3;

}





pair< Point, Point > crosspoint(const Circle &c1, const Circle &c2) {

  Real d = abs(c1.p - c2.p);

  Real a = acos((c1.r * c1.r + d * d - c2.r * c2.r) / (2 * c1.r * d));

  Real t = atan2(c2.p.imag() - c1.p.imag(), c2.p.real() - c1.p.real());

  Point p1 = c1.p + Point(cos(t + a) * c1.r, sin(t + a) * c1.r);

  Point p2 = c1.p + Point(cos(t - a) * c1.r, sin(t - a) * c1.r);

  return {p1, p2};

}



int N, K;

Points P;

vector<int> c;

vector<long double> r;

Circles C;

void input() {

    cin >> N >> K;

    P.resize(N);

    c.resize(N);

    C.resize(N);

    r.resize(N);

    for(int i = 0; i < N; i++) {

        cin >> P[i] >> c[i];

    }

}



void solve() {

    long double ok = 1e6;

    long double ng = 0.0;

    for(int timer = 0; timer <= 40; timer++) {

        bool clear = false;

        long double mid = (ok + ng) / 2;

        for(int i = 0; i < N; i++) {

            r[i] = mid / c[i];

            C[i] = Circle(P[i], r[i]);

        }

        Points Check;

        for(int i = 0; i < N; i++) {

            Check.push_back(P[i]);

            for(int j = i + 1; j < N; j++) {

                if(intersect(C[i], C[j])) {

                    auto tmp = crosspoint(C[i], C[j]);

                    Check.push_back(tmp.first);

                    Check.push_back(tmp.second);

                }

            }

        }

        for(auto p : Check) {

            int cnt = 0;

            for(int i = 0; i < N; i++) {

                if(abs(P[i] - p) <= r[i] + EPS)  cnt++;

            }

            if(cnt >= K) clear = true;

        }

        if(clear) ok = mid;

        else ng = mid;

    }

    cout << fixed << setprecision(20) << ok << endl;

}



int main() {

    input();

    solve();

    return 0;

}

// Optimized solution to the same problem (faster):
#include <bits/stdc++.h>

using namespace std;



using Real = long double;

using Point = complex< Real >;

const Real EPS = 1e-8, PI = acos(-1);



Point operator*(const Point &p, const Real &d) {

  return Point(real(p) * d, imag(p) * d);

}



inline bool eq(Real a, Real b) { return fabs(b - a) < EPS; }



istream &operator>>(istream &is, Point &p) {

  Real a, b;

  is >> a >> b;

  p = Point(a, b);

  return is;

}





struct Line {

  Point a, b;



  Line() = default;



  Line(Point a, Point b) : a(a), b(b) {}



  Line(Real A, Real B, Real C)

  {

    if(eq(A, 0)) a = Point(0, C / B), b = Point(1, C / B);

    else if(eq(B, 0)) b = Point(C / A, 0), b = Point(C / A, 1);

    else a = Point(0, C / B), b = Point(C / A, 0);

  }

};



Line g(Point a, Point b) {

    Point c = (a + b) / Point(2, 0);

    Point d = c + (b - a) * Point(0, 1);

    return Line(c, d);

}





struct Circle {

  Point p;

  Real r;



  Circle() = default;



  Circle(Point p, Real r) : p(p), r(r) {}

};



Circle h(Point a, Real acin, Point b, Real bcin) {

    assert(acin < bcin);

    Point ac = Point(acin, 0);

    Point bc = Point(bcin, 0);

    Point c = (a * ac + b * bc) / (ac + bc);

    Point d = (-a * ac + b * bc) / (-ac + bc);

    Real r = abs(c - d) / 2;

    return Circle((c + d) / Point(2, 0), r);

}



using Points = vector< Point >;

using Lines = vector< Line >;

using Circles = vector< Circle >;



Real cross(const Point &a, const Point &b) {

  return real(a) * imag(b) - imag(a) * real(b);

}



Real dot(const Point &a, const Point &b) {

  return real(a) * real(b) + imag(a) * imag(b);

}



Point projection(const Line &l, const Point &p) {

  double t = dot(p - l.a, l.a - l.b) / norm(l.a - l.b);

  return l.a + (l.a - l.b) * t;

}



Real distance(const Line &l, const Point &p) {

  return abs(p - projection(l, p));

}



bool intersect(const Line &l, const Line &m) {

  return abs(cross(l.b - l.a, m.b - m.a)) > EPS || abs(cross(l.b - l.a, m.b - l.a)) < EPS;

}



bool intersect(const Circle &c, const Line &l) {

  return distance(l, c.p) <= c.r + EPS;

}



int checker(Circle c1, Circle c2) {

  if(c1.r < c2.r) swap(c1, c2);

  Real d = abs(c1.p - c2.p);

  if(c1.r + c2.r < d) return 4;

  if(eq(c1.r + c2.r, d)) return 3;

  if(c1.r - c2.r < d) return 2;

  if(eq(c1.r - c2.r, d)) return 1;

  return 0;

}



bool intersect(Circle c1, Circle c2) {

    int tmp = checker(c1, c2);

    return 1 <= tmp and tmp <= 3;

}



Point crosspoint(const Line &l, const Line &m) {

  Real A = cross(l.b - l.a, m.b - m.a);

  Real B = cross(l.b - l.a, l.b - m.a);

  if(eq(abs(A), 0.0) && eq(abs(B), 0.0)) return m.a;

  return m.a + (m.b - m.a) * B / A;

}





pair< Point, Point > crosspoint(const Circle &c, const Line l) {

  Point pr = projection(l, c.p);

  Point e = (l.b - l.a) / abs(l.b - l.a);

  if(eq(distance(l, c.p), c.r)) return {pr, pr};

  double base = sqrt(c.r * c.r - norm(pr - c.p));

  return {pr - e * base, pr + e * base};

}



pair< Point, Point > crosspoint(const Circle &c1, const Circle &c2) {

  Real d = abs(c1.p - c2.p);

  Real a = acos((c1.r * c1.r + d * d - c2.r * c2.r) / (2 * c1.r * d));

  Real t = atan2(c2.p.imag() - c1.p.imag(), c2.p.real() - c1.p.real());

  Point p1 = c1.p + Point(cos(t + a) * c1.r, sin(t + a) * c1.r);

  Point p2 = c1.p + Point(cos(t - a) * c1.r, sin(t - a) * c1.r);

  return {p1, p2};

}



int N, K;

Points P;

vector<int> c;

vector<long double> r;

Circles C;

Points p;

void input() {

    cin >> N >> K;

    P.resize(N);

    c.resize(N);

    C.resize(N);

    r.resize(N);

    for(int i = 0; i < N; i++) {

        cin >> P[i] >> c[i];

    }

}





void f(vector<int> v) {

    sort(v.begin(), v.end(), [](auto const &l, auto const &r) {

        return c[l] < c[r];

    });

    if(c[v[0]] == c[v[2]]) {

        auto l1 = g(P[v[0]], P[v[1]]);

        auto l2 = g(P[v[1]], P[v[2]]);

        if(intersect(l1, l2)) {

            p.push_back(crosspoint(l1, l2));

        }

    } else if(c[v[0]] == c[v[1]]) {

        auto l1 = g(P[v[0]], P[v[1]]);

        auto c1 = h(P[v[1]], c[v[1]], P[v[2]], c[v[2]]);

        if(intersect(c1, l1)) {

            auto tmp = crosspoint(c1, l1);

            p.push_back(tmp.first);

            p.push_back(tmp.second);

        }

    } else if(c[v[1]] == c[v[2]]) {

        auto l1 = g(P[v[1]], P[v[2]]);

        auto c1 = h(P[v[0]], c[v[0]], P[v[1]], c[v[1]]);

        if(intersect(c1, l1)) {

            auto tmp = crosspoint(c1, l1);

            p.push_back(tmp.first);

            p.push_back(tmp.second);

        }

    } else {

        auto c1 = h(P[v[0]], c[v[0]], P[v[1]], c[v[1]]);

        auto c2 = h(P[v[1]], c[v[1]], P[v[2]], c[v[2]]);

        if(intersect(c1, c2)) {

            auto tmp = crosspoint(c1, c2);

            p.push_back(tmp.first);

            p.push_back(tmp.second);

        }

    }

}



void solve() {

    p.clear();

    long double ans = 1e9;

    for(int i = 0; i < N; i++) {

        p.push_back(P[i]);

        for(int j = 0; j < i; j++) {

            p.push_back((P[i]*c[i]+P[j]*c[j]) / Point(c[i]+c[j],0));

            for(int k = 0; k < j; k++) {

                f({i, j, k});

            }

        }

    }

    for(auto tmp : p) {

        vector<long double> v;

        for(int i = 0; i < N; i++) {

            v.push_back(abs(tmp - P[i]) * c[i]);

        }

        sort(v.begin(), v.end());

        ans = min(ans, v[K-1]);

    }

    cout << fixed << setprecision(20) << ans << endl;

}



int main() {

    input();

    solve();

    return 0;

}

// Fastest known solution for this problem: