#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>
#include <queue>
#include <string>
#include <map>
#include <set>
#include <tuple>
#include <deque>
#include <numeric>
#include <bitset>
#include <iomanip>
#include <cassert>
#include <chrono>
#include <random>
#include <limits>
#include <iterator>
#include <functional>
#include <sstream>
#include <complex>
using namespace std;

#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)

typedef long long ll;
typedef pair<int, int> P;
typedef pair<int, double> Pid;
typedef pair<double, int> Pdi;
typedef pair<ll, int> Pl;
typedef pair<int, pair<int, int>> PP;
constexpr double PI = 3.1415926535897932;   // acos(-1)
constexpr double EPS = 1e-9;
constexpr int INF = 1001001001;
constexpr int mod = 1e+9 + 7;

using ld = long double;
using Point = complex<ld>;
using Set = vector<Point>;
const ld pi = acos(-1);
constexpr ld eps = 1e-9;
constexpr ld inf = 1e12;

bool equal(ld a, ld b)  {return abs(a - b) < eps;}

// 外積
ld cross(const Point& a, const Point& b){
    return a.real() * b.imag() - a.imag() * b.real();
}

// 内積
ld dot(const Point& a, const Point& b){
    return a.real() * b.real() + a.imag() * b.imag();
}

enum CCW_RESULT{
    CCW = +1, CW = -1, BEHIND = +2, FRONT = -2, ON = 0
};
// a, b に対して、c がどの位置にあるか
int ccw(Point a, Point b, Point c){
    b -= a, c -= a;
    if(cross(b, c) > eps)   return CCW;     // 上側
    if(cross(b, c) < -eps)  return CW;      // 下側
    
    // cross(b, c) == 0
    if(dot(b, c) < 0)   return BEHIND;      // 同一直線上の左側
    if(norm(b) < norm(c))   return FRONT;   // 同一直線上の右側
    return ON;      // 線分 ab 上にある
}

namespace std{
bool operator<(const Point& a, const Point &b){
    return abs(real(a) - real(b)) > eps ? real(a) < real(b) : imag(a) < imag(b);
}
}

// 直線 (2つの点で表す)
struct Line : public vector<Point>{
    Line(const Point& a = Point(), const Point& b = Point()) : vector<Point>(2){
        begin()[0] = a;
        begin()[1] = b;
    }

    // Ax + By + C = 0
    Line(ld A, ld B, ld C){
        if(abs(A) < eps && abs(B) < eps){
            abort();
        }
        else if(abs(A) < eps){
            *this = Line(Point(0, -C / B), Point(1, -C / B));
        }
        else if(abs(B) < eps){
            *this = Line(Point(-C / A, 0), Point(-C / A, 1));
        }
        else{
            *this = Line(Point(0, -C / B), Point(-C / A, 0));
        }
    }
};

// 円
struct Circle{
    Point center;   // 中心座標
    ld radius;      // 半径
    Circle(const Point& p = 0, ld r = 0) : center(p), radius(r) {}
};


/* 交差判定 */
// 直線と直線
bool intersectLL(const Line& l, const Line& m){
    return abs(cross(l[1] - l[0], m[1] - m[0])) > eps ||    // 平行でない
           abs(cross(l[1] - l[0], m[0] - l[0])) < eps;      // 同じ直線
}
// 直線と線分
bool intersectLS(const Line &l, const Line& s){
    // cross(l[1] - l[0], s[0] - l[0]) : s[0] が左側
    // cross(l[1] - l[0], s[1] - l[0]) : s[1] が右側
    return cross(l[1] - l[0], s[0] - l[0]) * cross(l[1] - l[0], s[1] - l[0]) < eps;
}
// 直線と点
bool intersectLP(const Line& l, const Point& p){
    return abs(cross(l[1] - p, l[0] - p)) < eps;
}
// 線分と線分
bool intersectSS(const Line& s, const Line& t){
    return ccw(s[0], s[1], t[0]) * ccw(s[0], s[1], t[1]) <= 0 &&
           ccw(t[0], t[1], s[0]) * ccw(t[0], t[1], s[1]) <= 0;
}
// 線分と点
bool intersectSP(const Line& s, const Point& p){
    // 三角不等式
    return abs(s[0] - p) + abs(s[1] - p) - abs(s[1] - s[0]) < eps;
}


// 点 p から直線 l に下ろした垂線の足の座標
Point projection(const Line& l, const Point& p){
    ld t = dot(p - l[0], l[0] - l[1]) / norm(l[0] - l[1]);
    return l[0] + t * (l[0] - l[1]);
}
// reflection によって得た点を p' とすると、直線 l は線分 pp' の垂直二等分線となる。
Point reflection(const Line& l, const Point& p){
    return p + (ld)2 * (projection(l, p) - p);
}
// 点と直線の距離
ld distanceLP(const Line &l, const Point& p){
    return abs(p - projection(l, p));
}
// 直線と直線の距離 (交わるならば 0 を返す)
ld distanceLL(const Line& l, const Line& m){
    return intersectLL(l, m) ? 0 : distanceLP(l, m[0]);
}
// 直線と線分の距離
ld distanceLS(const Line& l, const Line &s){
    if(intersectLS(l, s))   return 0;
    return min(distanceLP(l, s[0]), distanceLP(l, s[1]));
}
// 線分と点の距離
ld distanceSP(const Line& s, const Point& p){
    const Point r = projection(s, p);
    if(intersectSP(s, r))   return abs(r - p);
    return min(abs(s[0] - p), abs(s[1] - p));
}
// 2 つの線分の距離
ld distanceSS(const Line& s, const Line& t){
    if(intersectSS(s, t))   return 0;
    return min(min(distanceSP(s, t[0]), distanceSP(s, t[1])),
               min(distanceSP(t, s[0]), distanceSP(t, s[1])));
}
// 2 直線の交点
Point crosspointLL(const Line& l, const Line& m){
    ld A = cross(l[1] - l[0], m[1] - m[0]);
    ld B = cross(l[1] - l[0], l[1] - m[0]);
    if(abs(A) < eps && abs(B) < eps)    return m[0];    // 同じ直線
    if(abs(A) < eps)    assert(false);
    return m[0] + B / A * (m[1] - m[0]);
}


// 円と直線との交点
vector<Point> crosspointCL(const Circle& c, const Line& l){
    vector<Point> res;
    ld d = distanceLP(l, c.center);     // 中心と直線の距離
    if(abs(d - c.radius) < eps){        // 接している
        res.push_back(projection(l, c.center));
        return res;
    }
    if(d > c.radius)   return res;     // 離れている
    // 垂線のベクトル
    Point h = projection(l, c.center);
    // 垂線の足から交点に向かうベクトル
    Point u = sqrt(c.radius * c.radius - d * d) * (l[1] - l[0]) / abs(l[1] - l[0]);
    res.push_back(h + u);
    res.push_back(h - u);
    return res;
}

// 2 つの円の位置関係
int intersectCC(const Circle& c1, const Circle& c2){
    ld d = abs(c1.center - c2.center), r1 = c1.radius, r2 = c2.radius;
    if(r1 + r2 < d)     return 0;               // 離れている
    if(abs(r1 + r2 - d) < eps)  return -2;      // 外接
    if(abs(d + r1 - r2) < eps)  return +1;      // c1 が c2 の中で内接
    if(abs(d + r2 - r1) < eps)  return -1;      // c2 が c1 の中で内接
    if(d + r1 < r2)     return +3;              // c1 が c2 の中
    if(d + r2 < r1)     return -3;              // c2 が c1 の中
    return 2;                                   // 2 つの交点を持つ
}

// 2 つの円の交点
vector<Point> crosspointCC(const Circle& c1, const Circle& c2){
    vector<Point> res;
    ld r1 = c1.radius, r2 = c2.radius, d = abs(c1.center - c2.center);
    if(d < eps)  return res;    // 中心が同じ
    int i = intersectCC(c1, c2);
    if(i == +1 || i == -1){     // 内接
        if(r2 < r1)
            // r1:r2 に外分する点
            res.push_back(c1.center + r1 / d * (c2.center - c1.center));
        else
            // r2:r1 に外分する点
            res.push_back(c2.center + r2 / d * (c1.center - c2.center));
        return res;
    }
    if(i == -2){    // 外接
        // 線分 o1o2 を r1:r2 で内分する点
        res.push_back((c1.center * c2.radius + c2.center * c1.radius) / (c1.radius + c2.radius));
        return res;
    }
    if(i == 0 || i == +3 || i == -3){   // 共通部分なし || 内部
        return res;
    }

    // 交点を通る直線の任意の位置ベクトルを v とすると、
    // v は円上にもあるので、|v-o1| = r1 と |v-o2| = r2 が成り立つ。
    // この 2 式から |v|^2 の項を取り除いてまとめると、
    // dot(2(o2-o1), v) + |o1|^2 - |o2|^2 - r1^2 + r2^2 = 0 となる。
    // v = (x, y) とすると、下の立式が成り立つ。
    // Point p = c2.center - c1.center;
    // ld A = 2 * p.real(), B = 2 * p.imag();
    // ld C = norm(c1.center) - norm(c2.center) - r1 * r1 + r2 * r2;
    // return crosspointCL(c1, Line(A, B, C));     // Ax + By + C = 0

    ld x = (c1.radius * c1.radius + d * d - c2.radius * c2.radius) / (2 * c1.radius * d);
    if(abs(x) > 1)  x = (x > 0 ? 1.0 : -1.0);
    ld a = acos(x);
    ld t = atan2(c2.center.imag() - c1.center.imag(), c2.center.real() - c1.center.real());
    Point p1 = c1.center + Point(cos(t + a) * c1.radius, sin(t + a) * c1.radius);
    Point p2 = c1.center + Point(cos(t - a) * c1.radius, sin(t - a) * c1.radius);
    res.push_back(p1);
    res.push_back(p2);
    return res;
}

int main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int n, k;
    cin >> n >> k;
    if(k == 1){
        cout << 0 << endl;
        return 0;
    }
    vector<Point> input(n);
    vector<ld> c(n);
    for(int i = 0; i < n; ++i){
        ld x, y;
        cin >> x >> y >> c[i];
        input[i] = Point(x, y);
    }

    ld lb = 0, ub = 400000;
    for(int loop = 0; loop < 100; ++loop){
        ld mid = (lb + ub) / 2;
        
        vector<Circle> cs(n);
        for(int i = 0; i < n; ++i){
            cs[i] = Circle(input[i], mid / c[i]);
        }

        vector<Point> ps = input;
        for(int i = 0; i < n; ++i){
            for(int j = 0; j < i; ++j){
                vector<Point> foo = crosspointCC(cs[i], cs[j]);
                ps.insert(ps.end(), foo.begin(), foo.end());
            }
        }

        int sz = ps.size();
        bool flag = false;
        for(int i = 0; i < sz; ++i){
            int cnt = 0;
            for(int j = 0; j < n; ++j){
                ld dist = norm(ps[i] - cs[j].center);
                dist = sqrt(dist);
                if(dist < cs[j].radius + eps)   ++cnt;
            }
            if(cnt >= k){
                flag = true;
                break;
            }
        }

        if(flag)    ub = mid;
        else    lb = mid;
    }

    cout << fixed << setprecision(10);
    cout << ub << endl;
}

Measured memory_bytes: 512