#pragma GCC optimize("Ofast")
#include <cstdio>
#include <cstdlib>
#include <string>
#include <algorithm>
#include <iostream>
#include <queue>
#include <vector>
#include <bitset>
#include <cmath>
#include <limits>
#include <iostream>
#include <map>
#include <set>
#include <stack>
#include <tuple>
#include <iomanip>
#include <functional>
#include <complex>

using namespace std;

using ll=long long int;
using pii=pair<int,int>;
using pil=pair<int,ll>;
using pli=pair<ll,int>;
using pll=pair<ll,ll>;
using psi=pair<string,int>;
using pis=pair<int,string>;
using psl=pair<string,ll>;
using pls=pair<ll,string>;
using pss=pair<string,string>;



template<typename T> using vc=vector<T>;
template<typename T> using vvc=vector<vector<T>>;
template<typename T> using vvvc=vector<vector<vector<T>>>;
template<typename T> using vvvvc=vector<vvvc<T>>;
template<typename T> using vvvvvc=vector<vvvvc<T>>;

template<class T,class U>inline constexpr bool chmin(T&a,const U b){if(a<=b)return false;a=b;return true;}
template<class T,class U>inline constexpr bool chmax(T&a,const U b){if(a>=b)return false;a=b;return true;}
#define bit(n,k) ( (n>>k)&1 )

inline void bin101(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr); 
    cout<<fixed<<setprecision(20);
}

//デバッグ
template<typename T>
inline void vout(const vector<T> &v){
    cout<<"\nstart\n";
    const int sz=v.size();
    for(int i=0;i<sz;i++){
        cout<<i<<" "<<v[i]<<'\n';
    }
    cout<<"end\n"<<endl;
}
//デバッグ
template<typename T>
inline void vout(const vvc<T> &v){
    cout<<"\nstart\n";
    const int sz=v.size();
    for(int i=0;i<sz;i++){
        int ssz=v[i].size();
        for(int j=0;j<ssz;j++){
            cout<<i<<" "<<j<<" "<<v[i][j]<<'\n';
        }
    }
    cout<<"end\n"<<endl;
}
//デバッグ
template<typename T>
inline void vout(const vvvc<T> &v){
    cout<<"\nstart\n";
    const int sz=v.size();
    for(int i=0;i<sz;i++){
        int ssz=v[i].size();
        for(int j=0;j<ssz;j++){
            int sssz=v[i][j].size();
            for(int k=0;k<sssz;k++){
                cout<<i<<" "<<j<<" "<<k<<" "<<v[i][j][k]<<'\n';
            }
        }
    }
    cout<<"end\n"<<endl;
}


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

//pair cin
template<typename T, typename U>
inline istream &operator>>(istream &is,pair<T,U> &p) {
  is>>p.first>>p.second;
  return is;
}

//ソート
template<typename T>
inline void vsort(vector<T> &v){
    sort(v.begin(),v.end());
}

//逆順ソート
template<typename T>
inline void rvsort(vector<T> &v){
  sort(v.rbegin(),v.rend());
}

//要素数a 初期値x
template<typename T>
inline vector<T> vmake(int a,T x){
  return vector<T>(a,x);
}

//data[a][b] 初期値x
template<typename T>
inline vector<vector<T>> vmake(int a,int b,T x){
  return vector<vector<T>>(a, vector<T>(b,x));
}

//data[a][b][c] 初期値x
template<typename T>
inline vector<vector<vector<T>>> vmake(int a,int b,int c,T x){
  return vector<vector<vector<T>>> (a, vector<vector<T>>(b, vector<T>(c, x)));
}

//data[a][b][c][d]　初期値x
template<typename T>
inline vector<vector<vector<vector<T>>>> vmake(int a,int b,int c,int d,T x){
  return vector<vector<vector<vector<T>>>> (a,vvvc<T>(b,vvc<T>(c,vc<T>(d,x))));
}

//data[a][b][c][d][e] 初期値x
template<typename T>
inline vvvvvc<T> vmake(int a,int b,int c,int d,int e,T x){
  return vvvvvc<T> (a,vvvvc<T>(b,vvvc<T>(c,vvc<T>(d,vc<T>(e,x)))));
}

//1ビットの数を返す
inline int popcount(int x){
  return __builtin_popcount(x);
}
//1ビットの数を返す
inline int popcount(ll x){
  return __builtin_popcountll(x);
}

//queのfront() pop()
template<typename T>
inline T pop(queue<T> &que){
    T x=que.front();
    que.pop();
    return x;
}

//priority_que top() pop()
template<typename T>
inline T pop(priority_queue<T> &que){
  T x=que.top();
  que.pop();
  return x;
}

//stack top() pop()
template<typename T>
inline T pop(stack<T> &st){
  T x=st.top();
  st.pop();
  return x;
}

#define intsz(x) ( (int)x.size()  )


constexpr int MAX=1<<30;
//constexpr ll INF=1LL<<62;
constexpr ll MOD=1e9+7;
int dx[]={1,-1,0,0},dy[]={0,0,-1,1};

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

using DD=double;


#define EPS 1e-10
#define eq(a,b) (abs( (a) - (b) )<EPS)
const DD PI=acosl(-1.0);
constexpr DD INF=1LL<<62;

//点
using P=complex<DD>;
//ベクトル
using V=P;
//線分
struct Segment{
    P a,b;
    Segment()=default;
    Segment(P a,P b) :a(a),b(b){}
    Segment(DD ax,DD ay,DD bx,DD by):a(ax,ay),b(bx,by){}
    Segment(DD r,P a) :a(a),b(a+polar(1.0,r)){} 

};
//直線
using Line=Segment;
//円
struct Circle{
    P p;
    DD r;
    Circle()=default;
    Circle(P p,DD r):p(p),r(r){}
};
using Polygon=vector<P>;

//++++++++++++++++基本計算++++++++++++++//
inline DD torad(const DD &deg){return deg*PI/180;}
inline DD todeg(const DD &rad){return rad*180/PI;}
//内積
inline DD dot(const V &a,const V &b){
    return real(a*conj(b));
}
//外積
inline DD cross(const V &a,const V &b){
    return imag(conj(a)*b);
}
//ベクトルvを反時計回りにr度回転
inline V rotate(const V &v,const DD r){
    return v*V(cos(r),sin(r));
}
inline bool xy(const P &a,const P &b){
    if(real(a)+EPS<=real(b)) return true;
    if(eq(real(a),real(b)) && imag(a)+EPS<imag(b)) return true;
    return false;
}
inline bool yx(const P &a,const P &b){
    if(imag(a)+EPS<imag(b)) return true;
    if(eq(imag(a),imag(b)) && real(a)+EPS<real(b)) return true;
    return false;
}

//++++++++++++++++平行や直交+++++++++++++++//
inline bool isOrthogonal(const V &a,const V &b){
    return eq(dot(a,b),0.0);
}
inline bool isOrthogonal(const Segment &a,const Segment &b){
    return eq(dot(a.a-a.b,b.a-b.b),0);
}
inline bool isParallel(const V &a,const V &b){
    return eq(cross(a,b),0.0);
}
inline bool isParallel(const Segment &a,const Segment &b){
    return eq(cross(a.a-a.b,b.a-b.b),0);
}
//線分a-bに対してcがどの位置にあるか
//ccwの簡略版 反時計回り:1 時計回り:-1 直線上:0
inline int ccw(const P &a,const P &b,const P &c){
    DD cr=cross(b-a,c-a);
    if(cr>EPS) return 1;
    if(cr<-EPS) return -1;
    return 0;
}

//線分a-bに対してcがどの位置にあるか
//反時計回り:1　時計回り:-1 直線上(a,b,c:-2 a,c,b:0 c,a,b:2) 
inline int ccwH(P a,P b,P c){
    b-=a;c-=a;
    if(cross(b,c)>EPS) return 1;
    if(cross(b,c)<-EPS) return -1;
    if(dot(b,c)<-EPS) return 2;
    if(norm(b)<norm(c)) return -2;
    return 0;
}


//+++++++++++++++射影+++++++++++++++++++++//
inline P project(const P &p,const Segment &s){
    V base=s.b-s.a;
    DD r=dot(p-s.a,base)/norm(base);
    return s.a+base*r;
}
inline P reflect(const P &p,const Segment &s){
    return p+(project(p,s)-p)*2.0;
}
/*++++++++++点との距離++++++++++++++++++*/
//点と直線の距離
inline DD dis(const P &p,const Line &l){return abs(cross(l.b-l.a,p-l.a))/abs(l.b-l.a);}
//点と線分の距離
inline DD disPS(const P &p,const Segment &s){
    if( dot(s.b-s.a,p-s.a)<0.0 ) return abs(p-s.a);
    if( dot(s.a-s.b,p-s.b)<0.0 ) return abs(p-s.b);
    return dis(p,s); //点と直線の距離
}


//+++++++++++++++線分と直線+++++++++++++++++//

//線分a-b,c-dは交差するか?
inline bool intersect(const P &a,const P &b,const P &c,const P &d){
    return(ccwH(a,b,c)*ccwH(a,b,d)<=0 && ccwH(c,d,a)*ccwH(c,d,b)<=0);
}
//線分s,tは交差するか？
inline bool intersect(const Segment &s,const Segment &t){
    return intersect(s.a,s.b,t.a,t.b);
}
//線分と線分の交点
//これをやる前にintersectで判定
inline P crossPoint(const Segment &s,const Segment &t){
    V base=t.b-t.a;
    DD d1=abs(cross(base,s.a-t.a));
    DD d2=abs(cross(base,s.b-t.a));
    DD r=d1/(d1+d2);
    return s.a+(s.b-s.a)*r;
}
//線分と線分の距離
inline DD dis(const Segment &s,const Segment t){
    if(intersect(s,t)) return 0.0;
    return min(min(disPS(t.a,s),disPS(t.b,s)),min(disPS(s.a,t),disPS(s.b,t)) );
}

//+++++++++++円++++++++++++++++//

//円cと直線lの交点
//abs(l,c.p)<c.r+EPSが必要
pair<P,P> crossPoint(const Line &l,const Circle &c){
    P pr=project(c.p,l);
    V e=(l.b-l.a)/(abs(l.b-l.a));
    DD base=sqrt(c.r*c.r-norm(pr-c.p));
    return make_pair(pr+e*base,pr-e*base);
}
//線分sと円cの交点
vector<P> crossPointSC(const Segment &s,const Circle &c){
    vector<P> ret;
    if(dis(c.p,s)>=c.r+EPS) return ret;
    auto p=crossPoint(s,c);
    if(dot(p.first-s.a,s.b-s.a)>0 && dot(p.first-s.b,s.a-s.b)>0) ret.push_back(p.first);
    if(dot(p.second-s.a,s.b-s.a)>0 && dot(p.second-s.b,s.a-s.b)>0) ret.push_back(p.second);
    if(xy(s.a,s.b)) sort(ret.begin(),ret.end(),xy);
    else sort(ret.rbegin(),ret.rend(),xy);
    return ret;
}

//共通接線の数
//離れている:4 外接:3 交わる:2 内接:1 内包:0
inline int intersect(const Circle &a,const Circle &b){
    DD d=abs(a.p-b.p);
    if(d>a.r+b.r+EPS) return 4;
    if(eq(d,a.r+b.r)) return 3;
    if(eq(d,abs(a.r-b.r))) return 1;
    if(d<abs(a.r-b.r)-EPS) return 0;
    return 2;
}

//円c1と円c2の交点
//これを使う前に交点があるかどうかを判定する
vector<P> crossPoint(const Circle &a,const Circle &b){
    vector<P> ret;
    if(abs(a.p-b.p)>a.r+b.r+EPS) return ret;
    DD d=abs(a.p-b.p);
    DD s=acos((a.r*a.r+d*d-b.r*b.r)/(2*a.r*d));
    DD t=arg(b.p-a.p);
    if(eq(s,0)) ret.emplace_back(a.p+polar(a.r,t+s));
    else ret.push_back(a.p+polar(a.r,t+s)),ret.push_back(a.p+polar(a.r,t-s));
    return ret;
}

//pがcの外にあるかの判定が必要
vector<P> TanLine(const P &p,const Circle &c){
    vector<P> ret;
    DD d=abs(p-c.p);
    if(d<=c.r-EPS) return ret;
    if(eq(d,c.r)){
        ret.push_back(p);
        return ret;
    } 
    return crossPoint(c,Circle(p,sqrt(d*d-c.r*c.r)));
}
//https://ei1333.github.io/luzhiled/snippets/geometry/template.html
//↑すごい。丸写し
//円c1,c2の共通接線
//接点をつないで線にしている(１個だけ追加するときに注意)
vector<Line> TanLine(Circle a,Circle b){
    vector<Line> ret;
    if(a.r<b.r) swap(a,b);
    DD g=abs(a.p-b.p);
    if(eq(g,0)) return ret;
    V u=(b.p-a.p)/g;
    V v=rotate(u,PI*0.5);
    for(DD s:{-1,1}){
        DD h=(a.r+s*b.r)/g;
        if(eq(1-h*h,0)){
            ret.emplace_back(a.p+u*a.r,a.p+(u+v)*a.r);
        }else if(1-h*h>0){
            V uu=u*h,vv=v*sqrt(1-h*h);
            ret.emplace_back(a.p+(uu+vv)*a.r,b.p-(uu+vv)*b.r*s);
            ret.emplace_back(a.p+(uu-vv)*a.r,b.p-(uu-vv)*b.r*s);
        }
    }
    return ret;
}

bool check(DD r,vector<P> &v,vector<DD> &c,int n,int k){
    vector<Circle> cv;
    for(int i=0;i<n;i++){
        cv.emplace_back(v[i],r/c[i]);
    }
    vector<P> koho;
    for(int i=0;i<n;i++){
        koho.push_back(v[i]);
        for(int j=i+1;j<n;j++){
            auto t=crossPoint(cv[i],cv[j]);
            for(int k=0;k<t.size();k++){
                koho.push_back(t[k]);
            }
        }
    }
    for(int i=0;i<(int)koho.size();i++){
        P x=koho[i];
        int cnt=0;
        for(int j=0;j<n;j++){
            if( abs(x-v[j])<=r/c[j]+EPS ) cnt++;
        }
        if(cnt>=k) return true;
    }
    return false;
}


signed main(){
    bin101();

    int n,k;
    cin>>n>>k;
    vector<P> v;
    vector<DD> c;
    for(int i=0;i<n;i++){
        DD x,y,t;
        cin>>x>>y>>t;
        v.emplace_back(x,y);
        c.push_back(t);
    }
    if(k==1){
        cout<<0<<endl;
        return 0;
    }
    DD ok=200000.0,ng=0.0;
    while(ok-ng>=0.00000001){
        DD mid=(ok+ng)/2;
        if( check(mid,v,c,n,k) ) ok=mid;
        else ng=mid;
    }
    cout<<ok<<endl;
}

Measured memory_bytes: 384