#include <iostream>
#include <string>
#include <vector>
#include <queue>
#include <deque>
#include <algorithm>
#include <set>
#include <map>
#include <bitset>
#include <cmath>
#include <functional>
#include <iomanip>
#define vll vector<ll>
#define vvvl vector<vvl>
#define vvl vector<vector<ll>>
#define VV(a, b, c, d) vector<vector<d> >(a, vector<d>(b, c))
#define VVV(a, b, c, d) vector<vvl>(a, vvl(b, vll (c, d)));
#define re(c, b) for(ll c=0;c<b;c++)
#define all(obj) (obj).begin(), (obj).end()
typedef long long int ll;
typedef long double ld;
using namespace std;

/*
complexではなくpointクラスを作った.

norm: ノルム
abs: 原点からの距離
arg: 角度(−π
−
π
からπ
π
)
dot: 内積
cross,det: 外積(行列式)
proj: 直線(0,0),(x,y)への正射影
ccwはa->b->cの順で進むとき
1ならccw(反時計回り), -1ならcw(時計回り), 2なら折り返し, -2なら直進, 0なら線分上に折り返し
*/

namespace D2 {
const ld eps = 1e-7;
bool eq(const ld &a, const ld &b) { return std::abs(a-b)<eps; }

struct point {
    ld x, y;
    point():x(0),y(0) {}
    point(ld x, ld y):x(x),y(y) {}

    point operator+=(const point &p) { x+=p.x; y+=p.y; return *this; }
    point operator-=(const point &p) { x-=p.x; y-=p.y; return *this; }
    point operator*=(const point &p) { ld tx = x; x=x*p.x-y*p.y; y=y*p.x+tx*p.y; return *this; }
    point operator*=(const ld &d) { x*=d; y*=d; return *this; }
    point operator/=(const ld &d) { x/=d; y/=d; return *this; }
    point operator+(const point &p) const { return point(*this)+=p; }
    point operator-(const point &p) const { return point(*this)-=p; }
    point operator*(const ld &d) const { return point(*this)*=d; }
    point operator*(const point &p) const { return point(*this)*=p; }
    point operator/(const ld &d) const { return point(*this)/=d; }
    point operator-() const { return point(-x,-y); }
    bool operator<(const point &p) const { return std::abs(x- p.x)>eps ? x < p.x-eps : y < p.y-eps; }
    bool operator==(const point &p) const { return std::abs(x-p.x)<eps and std::abs(y-p.y)<eps; }
    bool operator!=(const point &p) const { return !(point(*this)==p); }

    ld norm() const { return x*x+y*y; }
    ld abs() const { return sqrt(norm()); }
    ld arg() const { return atan2(y, x); }

    ld dot(const point &p) const { return x*p.x+y*p.y; }
    ld cross(const point &p) const { return x*p.y-y*p.x; }
    ld det(const point &p) const { return x*p.y-y*p.x; }
    point proj(const point &p) const { ld k = dot(p)/norm(); return point(x*k,y*k); }
    ld pi(){
      ld a = arg();
      if(a < 0) return (2*M_PI + a);
      return a;
    }
};
point operator*(const ld &d, const point &p) { point q = p*d; return q; }
std::ostream &operator<<(std::ostream &os, const point &p) { os << "(" << p.x << "," << p.y << ")"; return os; }

point polar(const ld &r, const ld &th) { return point(r*std::cos(th),r*std::sin(th)); }
ld abs(const point &p) { return p.abs(); }
ld norm(const point &p) { return p.norm(); }
ld dot(const point &a, const point &b) { return a.dot(b); }
ld cross(const point &a, const point &b) { return a.cross(b); }
ld det(const point &a, const point &b) { return a.det(b); }
ld arg(const point &a) { return a.arg(); }
/*
 *           1
 *  ------------------
 *    -2 |a  0  b| 2
 *  ------------------
 *          -1
 */
int ccw(point a, point b, point c)
{
    b -= a, c -= a;
    if (b.cross(c) > eps)        return +1;
    if (b.cross(c) < -eps)       return -1;
    if (b.dot(c) < -eps)         return -2; // c -- a -- b
    if (b.norm() < c.norm()-eps) return +2; // a -- b -- c
    return 0;
}
}

/*
直線クラス. 線分も兼ねている.

vec: 方向ベクトル
norm: ノルム
abs: 原点からの距離
proj: 正射影
refl: 線対称な点
各関数名は以下の規則に従っている.

接頭辞(1文字, 動作)
i: 交差判定
c: 交点
d: 距離
接尾辞(2文字, 引数)
l: 直線
s: 線分
p: 点
*/

namespace D2 {
/*
  depends on
  point
*/
struct line {
    point a, b;
    line(){}
    line(point a, point b) : a(a), b(b) {}

    point vec() const { return b-a; }
    ld abs() const { return vec().abs(); }
    ld norm() const { return vec().norm(); }
    point proj(const point &p) const { return a+vec().proj(p-a); }
    point refl(const point &p) const { return proj(p)*2-p; }
};
std::ostream &operator<<(std::ostream &os, const line &l) { os << l.a << " - " << l.b; return os; }

bool ill(const line &l, const line &m) { return std::abs(l.vec().det(m.vec())) > eps; }
bool ils(const line &l, const line &s) { return ccw(l.a,l.b,s.a)*ccw(l.a,l.b,s.b)<=0; }
bool isl(const line &s, const line &l) { return ils(l,s); }
bool iss(const line &s, const line &t) { return ils(s,t) and ils(t,s); }
point cll(const line &l, const line &m) { return l.a+l.vec()*(m.vec().det(m.a-l.a)/m.vec().det(l.vec())); }
ld dlp(const line &l, const point &p) { return (l.proj(p)-p).abs(); }
ld dpl(const point &p, const line &l) { return dlp(l,p); }
ld dll(const line &l, const line &m) { return ill(l,m) ? 0.0 : dlp(l,m.a); }
ld dps(const point &p, const line &s) { return ccw(s.a,s.b,s.proj(p)) ? std::min((s.a-p).abs(), (s.b-p).abs()) : (s.proj(p)-p).abs(); }
ld dsp(const line &s, const point &p) { return dps(p,s); }
ld dss(const line &s, const line &m) { return iss(s,m)? 0.0 : std::min(std::min(dps(m.a,s),dps(m.b,s)), std::min(dps(s.a,m),dps(s.b,m))); }

}
/*
円クラス

各関数名は以下の規則に従っている.

接頭辞(1文字, 動作)
i: 交差判定
c: 交点
d: 距離
接尾辞(2文字, 引数)
c: 円
l: 直線
s: 線分
p: 点
tangent: 円の中心から伸びる角度thの半直線と垂直に交わる円の接線
common_tangent: 2円の共通接線(最大4本)
*/

namespace D2 {
/*
  depends on
  point
  (line)
*/

struct circle {
    point o;
    ld r;
    circle(){}
    circle(point o, ld r) : o(o), r(r) {}
    circle(ld r, point o) : o(o), r(r) {}
};
std::ostream &operator<<(std::ostream &os, const circle &c) { os << c.o << " - " << c.r; return os; }

int icc(const circle &c, const circle &d) {
    /*
      1 : intersect
      0 : distinct
      -1: c < d
      -2: c > d

      intersect or contain : true
      distinct             : false
    */
    ld od = (c.o-d.o).abs();
    return c.r+d.r<od+eps ? 0 : od+c.r<d.r+eps ? -1 : od+d.r<c.r+eps ? -2 : 1;
}

int icl(const circle &c, const line &l) {
    /*
      number of crosspoint
    */
    ld d = (l.proj(c.o)-c.o).norm()-c.r*c.r;
    return d>eps ? 0 : std::abs(d)<eps ? 1 : 2;
}
int ilc(const line &l, const circle &c) { return icl(c,l); }
int ics(const circle &c, const line &s) {
    /*
      0 : distinct
      1 : intersect 1 point
      2 : s is in c
    */
    if (!icl(c, s)) return 0;
    ld da = (s.a - c.o).abs();
    ld db = (s.b - c.o).abs();
    if ((da < c.r-eps) and (db < c.r-eps)) return 0;
    if ((da < c.r-eps) xor (db < c.r-eps)) return 1;
    return ccw(s.a, s.b, s.proj(c.o)) ? 0 : 2;
}
int isc(const line &s, const circle &c) { return ics(c,s); }

ld dcp(const circle &c, const point &p) {
    ld d = (c.o-p).abs();
    if(d < c.r+eps) return 0;
    return d-c.r;
}
ld dpc(const point &p, const circle &c) { return dcp(c,p); }

ld dcl(const circle &c, const line &l) { return std::max(dlp(l,c.o)-c.r,(ld)0.); }
ld dlc(const line &l, const circle &c) { return dcl(c,l); }
ld dcs(const circle &c, const line &s) { return std::max(dps(c.o,s)-c.r,(ld)0.); }
ld dsc(const line &s, const circle &c) { return dcs(c,s); }

std::pair<point,point> ccl(const circle &c, const line &l) {
    point h = l.proj(c.o), p = sqrt(c.r*c.r-(h-c.o).norm())*(l.b-l.a)/(l.b-l.a).abs();
    return std::pair<point,point>(h-p,h+p);
}
std::pair<point,point> clc(const line &l, const circle &c) { return ccl(c,l); }

std::pair<point,point> ccc(const circle &c1, const circle &c2) {
    if(!icc(c1,c2)) return std::pair<point,point>(c1.o,c2.o);
    ld w = (c2.o-c1.o).abs(), th = (c2.o-c1.o).arg();
    ld dth = std::acos((c1.r*c1.r+w*w-c2.r*c2.r)/(2.*c1.r*w));
    return std::pair<point,point>(c1.o+D2::polar(c1.r,th-dth),c1.o+D2::polar(c1.r,th+dth));
}

line tangent(const circle &c, const ld &th) {
    point h = c.o+D2::polar(c.r,th);
    point p = D2::polar(c.r,th)*D2::point(0,1);
    return line(h-p,h+p);
}

std::vector<line> common_tangent(const circle &c, const circle &d) {
    std::vector<line> ret;
    ld dist = (d.o - c.o).abs(), th = (d.o - c.o).arg();
    if (std::abs(c.r - d.r) < dist) { // outer
        ld dth = std::acos((c.r - d.r) / dist);
        ret.push_back(tangent(c, th - dth));
        ret.push_back(tangent(c, th + dth));
    }
    if (std::abs(c.r + d.r) < dist) {
        ld dth = std::acos((c.r + d.r) / dist);
        ret.push_back(tangent(c, th - dth));
        ret.push_back(tangent(c, th + dth));
    }
    return ret;
}
}
using namespace D2;
int main(int argc, char const *argv[]) {
  ll n, k;std::cin >> n >> k;
  vector<vector<ld>> d(n, vector<ld>(3));
  re(i,n) std::cin >> d[i][0] >> d[i][1] >> d[i][2];

  ld l = 0, r = 1000000000;
  for(int cnt=0;cnt<200;cnt++){
    ld mid = (l+r)/2;
    vector<point> candi;

    // n*(n-1)/2 *2 個の交差点 or n個の中心
    for(int i=0;i<n;i++){
      for(int j=i+1;j<n;j++){
        circle a(point(d[i][0], d[i][1]), mid/d[i][2]);
        circle b(point(d[j][0], d[j][1]), mid/d[j][2]);
        if(icc(a, b)<=0) continue;
        pair<point, point> c = ccc(a, b);
        candi.push_back(c.first);
        candi.push_back(c.second);
      }
    }
    for(int i=0;i<n;i++) candi.push_back(point(d[i][0], d[i][1]));
    ll max_cnt = 0;

    for(int x=0;x<candi.size();x++){
      point p = candi[x];
      ll tmp = 0;
      for(int i=0;i<n;i++){
        ld x = abs(d[i][0] - p.x);
        ld y = abs(d[i][1] - p.y);
        ld ok = (mid/d[i][2])*(mid/d[i][2]);
        if(x*x+y*y<=ok+eps) tmp++;
      }
      max_cnt = max(max_cnt, tmp);
      //std::cout << p.x << " " << p.y << " " << tmp << '\n';
    }

    //std::cout << mid << " " << max_cnt << '\n';
    if(max_cnt>=k) r = mid;
    else l = mid;
  }
  std::cout << fixed << setprecision(20) << r << '\n';
  return 0;
}


Measured memory_bytes: 1016