#include <bits/stdc++.h>
#define rep(i,n)for(int i=0;i<(n);i++)
using namespace std;
typedef long long ll;
typedef pair<int,int>P;
 
const int MOD=1000000007;
const int INF=0x3f3f3f3f;
const ll INFL=0x3f3f3f3f3f3f3f3f;
 
#define _USE_MATH_DEFINES
#include<bits/stdc++.h>
#define EPS (1e-10)
#define equals(a,b)(fabs((a)-(b))<EPS)
using namespace std;
 
 
struct Point {
	double x, y;
	Point(double x = 0, double y = 0) :x(x), y(y) {}
	Point operator+(Point p) { return Point(x + p.x, y + p.y); }
	Point operator-(Point p) { return Point(x - p.x, y - p.y); }
	Point operator*(double a) { return Point(a*x, a*y); }
	Point operator/(double a) { return Point(x / a, y / a); }
 
	double norm() { return x*x + y*y; }
	double abs() { return sqrt(norm()); }
 
	bool operator<(const Point&p)const {
		return x != p.x ? x < p.x : y < p.y;
	}
	bool operator==(const Point&p)const {
		return fabs(x - p.x) < EPS&&fabs(y - p.y) < EPS;
	}
};
typedef vector<Point>Polygon;
typedef Point Vector;
double norm(Vector a) {
	return a.x*a.x + a.y*a.y;
}
double abs(Vector a) {
	return sqrt(norm(a));
}
struct Segment {
	Point p1, p2;
};
typedef Segment Line;
class Circle {
public:
	Point c;
	double r;
	Circle(Point c = Point(), double r = 0.0) :c(c), r(r) {}
};
double dot(Vector a, Vector b) {
	return a.x*b.x + a.y*b.y;
}
double cross(Vector a, Vector b) {
	return a.x*b.y - a.y*b.x;
}
bool isOrthogonal(Vector a, Vector b) {
	return equals(dot(a, b), 0.0);
}
bool isOrthogonal(Point a1, Point a2, Point b1, Point b2) {
	return isOrthogonal(a1 - a2, b1 - b2);
}
bool isOrthogonal(Segment s1, Segment s2) {
	return equals(dot(s1.p2 - s1.p1, s2.p2 - s2.p1), 0.0);
}
bool isParallel(Vector a, Vector b) {
	return equals(cross(a, b), 0.0);
}
bool isParallel(Point a1, Point a2, Point b1, Point b2) {
	return isParallel(a1 - a2, b1 - b2);
}
bool isParallel(Segment s1, Segment s2) {
	return equals(cross(s1.p2 - s1.p1, s2.p2 - s2.p1), 0.0);
}
Point project(Segment s, Point p) {
	Point base = s.p2 - s.p1;
	double r = dot(p - s.p1, base) / base.norm();
	return s.p1 + base*r;
}
Point reflect(Segment s, Point p) {
	return p + (project(s, p) - p)*2.0;
}
#define COUNTER_CLOCKWISE 1
#define CLOCKWISE -1
#define ONLINE_BACK 2
#define ONLINE_FRONT -2
#define ON_SEGMENT 0
int ccw(Point p0, Point p1, Point p2) {
	Point a = p1 - p0;
	Point b = p2 - p0;
	if (cross(a, b) > EPS)return COUNTER_CLOCKWISE;
	if (cross(a, b) < -EPS)return CLOCKWISE;
	if (dot(a, b) < -EPS)return ONLINE_BACK;
	if (a.norm() < b.norm())return ONLINE_FRONT;
	return ON_SEGMENT;
}
bool intersect(Point p1, Point p2, Point p3, Point p4) {
	return (ccw(p1, p2, p3)*ccw(p1, p2, p4) <= 0 &&
		ccw(p3, p4, p1)*ccw(p3, p4, p2) <= 0);
}
bool intersect(Segment s1, Segment s2) {
	return intersect(s1.p1, s1.p2, s2.p1, s2.p2);
}
double getDistance(Point a, Point b) {
	return abs(a - b);
}
double getDistanceLP(Line l, Point p) {
	return abs(cross(l.p2 - l.p1, p - l.p1) / abs(l.p2 - l.p1));
}
double getDistanceSP(Segment s, Point p) {
	if (dot(s.p2 - s.p1, p - s.p1) < 0.0)return abs(p - s.p1);
	if (dot(s.p1 - s.p2, p - s.p2) < 0.0)return abs(p - s.p2);
	return getDistanceLP(s, p);
}
double getDistance(Segment s1, Segment s2) {
	if (intersect(s1, s2))return 0.0;
	return min(min(getDistanceSP(s1, s2.p1), getDistanceSP(s1, s2.p2)),
		min(getDistanceSP(s2, s1.p1), getDistanceSP(s2, s1.p2)));
}
int contains(Polygon g, Point p) {
	int n = g.size();
	bool x = false;
	rep(i, n) {
		Point a = g[i] - p, b = g[(i + 1) % n] - p;
		if (abs(cross(a, b)) < EPS&&dot(a, b) < EPS)return 1;
		if (a.y > b.y)swap(a, b);
		if (a.y < EPS&&EPS<b.y&&cross(a, b)>EPS)x = !x;
	}
	return x ? 2 : 0;
}
bool isconvex(Polygon g) {
	int back = 3;
	rep(i, g.size()) {
		int d = ccw(g[(i + g.size() - 1) % g.size()], g[i], g[(i + 1) % g.size()]);
		if (back != 3 && d != back)
			return false;
		else back = d;
	}
	return true;
}
double area(Polygon g) {
	double cnt = 0;
	rep(i, g.size())
		cnt += g[i].x*g[(i + 1) % g.size()].y - g[(i + 1) % g.size()].x*g[i].y;
	return abs(cnt) / 2;
}
pair<Point, Point>getCrossPoints(Circle c, Line l) {
	Vector pr = project(l, c.c);
	Vector e = (l.p2 - l.p1) / abs(l.p2 - l.p1);
	double base = sqrt(c.r*c.r - norm(pr - c.c));
	return make_pair(pr + e*base, pr - e*base);
}
Point getCrossPoint(Segment s1, Segment s2) {
	Vector base = s2.p2 - s2.p1;
	double d1 = abs(cross(base, s1.p1 - s2.p1));
	double d2 = abs(cross(base, s1.p2 - s2.p1));
	double t = d1 / (d1 + d2);
	return s1.p1 + (s1.p2 - s1.p1)*t;
}
double getDistance(Circle c1, Circle c2) {
	return max(0.0, getDistance(c1.c, c2.c) - c1.r - c2.r);
}
double getDistance(Circle c, Point p) {
	return max(0.0, getDistance(c.c, p) - c.r);
}
bool intersect(Circle c, Point p) {
	return abs(getDistance(c, p)) < EPS;
}
Polygon andrewScan(Polygon s){
	Polygon u,l;
	if(s.size()<3)return s;
	sort(s.begin(),s.end());
	u.push_back(s[0]);
	u.push_back(s[1]);
	l.push_back(s[s.size()-1]);
	l.push_back(s[s.size()-2]);
	for(int i=2;i<s.size();i++){
		for(int n=u.size();n>=2&&ccw(u[n-2],u[n-1],s[i])!=CLOCKWISE;n--){
			u.pop_back();
		}
		u.push_back(s[i]);
	}
	for(int i=s.size()-3;i>=0;i--){
		for(int n=l.size();n>=2&&ccw(l[n-2],l[n-1],s[i])!=CLOCKWISE;n--){
			l.pop_back();
		}
		l.push_back(s[i]);
	}
	reverse(l.begin(),l.end());
	for(int i=u.size()-2;i>=1;i--)l.push_back(u[i]);
	return l;
}
 
double arg(Vector p){return atan2(p.y,p.x);}
Vector polar(double a,double r){return Point(cos(r)*a,sin(r)*a);}
 
bool intersect(Circle c1,Circle c2){
	return abs(c1.r-c2.r)<=getDistance(c1.c,c2.c)&&getDistance(c1.c,c2.c)<=c1.r+c2.r;
}
bool overlap(Circle c1,Circle c2){
	return getDistance(c1.c,c2.c)&&getDistance(c1.c,c2.c)<=c1.r+c2.r;
}
pair<Point,Point>getCrossPoints(Circle c1,Circle c2){
	assert(intersect(c1,c2));
	double d=abs(c1.c-c2.c);
	double a=acos((c1.r*c1.r+d*d-c2.r*c2.r)/(2*c1.r*d));
	double t=arg(c2.c-c1.c);
	return make_pair(c1.c+polar(c1.r,t+a),c1.c+polar(c1.r,t-a));
}
 
 
int n,K;
double x[100],y[100],c[100];
 
bool C(double t){
	vector<Circle>cs;
	rep(i,n){
		cs.push_back({Point(x[i],y[i]),t/c[i]});
	}
	vector<Point>ps;
	rep(i,n){
		ps.push_back(cs[i].c);
	}
	rep(i,n)for(int j=i+1;j<n;j++){
		if(!intersect(cs[i],cs[j]))continue;
		auto p=getCrossPoints(cs[i],cs[j]);
		ps.push_back(p.first);
		ps.push_back(p.second);
	}
	int Max=0;
	for(auto&p:ps){
		int cnt=0;
		rep(i,n){
			if(intersect(cs[i],p))cnt++;
		}
		Max=max(Max,cnt);
	}
	return Max>=K;
}
 
int main(){
	cin>>n>>K;
	rep(i,n)scanf("%lf%lf%lf",&x[i],&y[i],&c[i]);
	double ok=1e9,ng=0;
	rep(i,200){
		double t=(ok+ng)/2;
		if(C(t))ok=t;
		else ng=t;
	}
	printf("%.12lf\n",ok);
}

Measured memory_bytes: 512