#include <bits/stdc++.h>
#define MOD 1000000007LL
#define EPS 1e-8
#define equals(a,b) (fabs((a)-(b))<EPS)
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
typedef pair<P,int> PP;

double add(double a,double b){
    if(abs(a+b)<EPS*(abs(a)+abs(b)))return 0.0;
    return a+b;
}

class Point {
public:
	double x, y;
	Point() {}
	Point(double xx, double yy) {
		x = xx;
		y = yy;
	}
	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 abs() {
		return sqrt(norm());
	}
	double norm() {
		return x * x + y * y;
	}

	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 Point Vector;
struct Segment {
	Point p1, p2;
	Segment() {}
	Segment(Point pp1,Point pp2){
		p1=pp1;
		p2=pp2;
	}
};

typedef Segment Line;

class Circle {
public:
	Point c;
	double r;
	Circle() {

	}
	Circle(Point cc, double rr) {
		c = cc;
		r = rr;
	}
};

typedef vector<Point> Polygon;

double norm(Vector v) {
	return v.x * v.x + v.y * v.y;
}

double abs(Vector v) {
	return sqrt(norm(v));
}


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;
}

static const int COUNTER_CLOCKWISE = 1;
static const int CLOCKWISE = -1;
static const int ONLINE_BACK = 2;
static const int ONLINE_FRONT = -2;
static const int ON_SEGMENT = 0;

int ccw(Point p0, Point p1, Point p2) {
	Vector a = p1 - p0;
	Vector 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);
}

//直行判定
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) {
	Vector base = s.p2 - s.p1;
	double r = dot(p - s.p1, base) / norm(base);
	return s.p1 + base * r;
}

Point reflect(Segment s, Point p) {
	return p + (project(s, p) - p) * 2.0;
}

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)));
}

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;
}

Point getLineCrossPoint(Line l1,Line l2){
	Vector base=l1.p2-l1.p1;
	double a=cross(l2.p2-l2.p1,base);
	double b=cross(l1.p1-l2.p1,base);
	return l2.p1+(l2.p2-l2.p1)*b/a;
}

bool intersect(Circle c, Line l) {
	return c.r >= (getDistanceLP(l, c.c));
}

pair<Point, Point> getCrossPoints(Circle c, Line l) {
	assert(intersect(c, 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);
}

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) {
	if (c1.r + c2.r < getDistance(c1.c, c2.c))return false;
	if (abs(c1.r - c2.r) > getDistance(c1.c, c2.c))return false;
	return true;
}

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.0 * 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;
int x[61],y[61],c[61];
Circle cr[61];

bool solve(Point p){
	int cnt=0;
	for(int i=0;i<n;i++){
		double dx=cr[i].c.x-p.x;
		dx=dx*dx;
		double dy=cr[i].c.y-p.y;
		dy=dy*dy;
		if(sqrt(dx+dy)<=cr[i].r+EPS){
			cnt++;
		}
	}
	return cnt>=k;
}

bool C(double co){
	for(int i=0;i<n;i++){
		double r=(double)co/c[i];
		cr[i]=Circle(Point(x[i],y[i]),r);
		//printf("%d %.5f %.5f %.5f\n",i,cr[i].c.x,cr[i].c.y,r);
	}
	for(int i=0;i<n;i++){
		if(solve(cr[i].c)){
			return true;
		}
	}
	for(int i=0;i<n;i++){
		for(int j=i+1;j<n;j++){
			if(intersect(cr[i],cr[j])){
				pair<Point,Point> ppos=getCrossPoints(cr[i],cr[j]);
				if(solve(ppos.first)){
					return true;
				}
				if(solve(ppos.second)){
					return true;
				}
			}
		}
	}
	return false;
}

int main(void){
	scanf("%d%d",&n,&k);
	for(int i=0;i<n;i++){
		scanf("%d%d%d",&x[i],&y[i],&c[i]);
	}

	double l=0.0,r=1e7;
	for(int i=0;i<100;i++){
		double mid=(l+r)/2.0;
		if(C(mid)){
			r=mid;
		}else{
			l=mid;
		}
	}
	printf("%.10f\n",r);
	return 0;
}


Measured memory_bytes: 384