#include <bits/stdc++.h>

using namespace std;

using ll = int64_t;
using ull = uint64_t;
using i32 = int32_t;
using u32 = uint32_t;
using i64 = int64_t;
using u64 = uint64_t;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using ld = double;

#define X first
#define Y second

#ifndef ONLINE_JUDGE
#define FWRITE
#endif

namespace io
{

#ifndef FWRITE
#include <unistd.h>
#endif
	const int BUFSIZE = 1 << 20;

	int isize, osize;
	char ibuf[BUFSIZE + 10], obuf[BUFSIZE + 10];
	char* is, * it, * os = obuf, * ot = obuf + BUFSIZE;

	char getchar()
	{
		if (is == it)
		{
			is = ibuf;
#ifdef FWRITE
			it = ibuf + fread(ibuf, 1, BUFSIZE, stdin);
#else
			it = ibuf + read(STDIN_FILENO, ibuf, BUFSIZE);
#endif
			if (is == it) return EOF;
		}
		return *is++;
	}

	char getalpha()
	{
		char c = getchar();
		while (!isalpha(c)) c = getchar();
		return c;
	}

	void putchar(char c)
	{
		*os++ = c;
		if (os == ot)
		{
#ifdef FWRITE
			fwrite(obuf, 1, BUFSIZE, stdout);
#else
			write(STDOUT_FILENO, obuf, BUFSIZE);
#endif
			os = obuf;
		}
	}

	int inp() {
		int x = 0, f = 0; char ch;
		for (ch = getchar(); !isdigit(ch); ch = getchar())
		{
			if (ch == EOF) return -1;
			if (ch == '-') f = 1;
		}
		for (; isdigit(ch); x = x * 10 + ch - '0', ch = getchar());
		return f ? -x : x;
	}

	ll inp_ll() {
		ll x = 0; int f = 0; char ch;
		for (ch = getchar(); !isdigit(ch); ch = getchar())
			if (ch == '-') f = 1;
		for (; isdigit(ch); x = x * 10 + ch - '0', ch = getchar());
		return f ? -x : x;
	}

	template<class T>
	bool read(T& x)
	{
		x = 0;
		char ch = getchar();
		if (ch == EOF) return 0;
		for (; !isdigit(ch); )
		{
			ch = getchar();
			if (ch == EOF) return 0;
		}
		for (; isdigit(ch); x = x * 10 + ch - '0', ch = getchar());
		return 1;
	}

	template<class T>
	void write(T x)
	{
		static char s[22];
		static char* it = s + 20;
		static char* end = s + 20;

		if (x < 0)
		{
			putchar('-');
			x = -x;
		}

		do
		{
			*--it = x % 10 + '0';
			x /= 10;
		} while (x);
		/*
		if (!x)
			*-- it = '0';
		while (x)
		{
			*-- it = x%10+'0';
			x /= 10;
		}
		*/
		for (; it < end; ++it)
			putchar(*it);
	}

	template<>
	void write(const char* s)
	{
		for (; *s; ++s) putchar(*s);
	}

	template<>
	void write(char c)
	{
		putchar(c);
	}

	template<class T, class V>
	void write(T x, V y)
	{
		write(x);
		write(y);
	}

	template<class T>
	void writeln(T x)
	{
		write(x);
		putchar('\n');
	}

	struct ender
	{
		~ender()
		{
			if (os != obuf)
#ifdef FWRITE
				fwrite(obuf, 1, os - obuf, stdout);
#else
				write(STDOUT_FILENO, obuf, os - obuf);
#endif
		}
	}__ender;

}

template<class T>
void print(const T& a)
{
	for (auto x : a) printf("%d ", x); puts("");
}

int64_t power(int64_t a, int64_t b, int64_t p)
{
	if (!b) return 1;
	int64_t t = power(a, b >> 1, p);
	t = t * t % p;
	if (b & 1) t = t * a % p;
	return t;
}

//mt19937_64 rd(chrono::steady_clock::now().time_since_epoch().count());
mt19937 rd(chrono::steady_clock::now().time_since_epoch().count());

using namespace io;

template<class T>
inline void freshmin(T& a, const T& b)
{
	if (a > b) a = b;
}

template<class T>
inline void freshmax(T& a, const T& b)
{
	if (a < b) a = b;
}

const ll B = 31;
const ll MOD = 10007;
const int INF = 1000000010;
const int MAXN = 111;
const int MAXK = 20;

int dx[] = { -1, 1, 0, 0 };
int dy[] = { 0, 0, -1, 1 };

ld det(ld x1, ld y1, ld x2, ld y2, ld x3, ld y3)
{
	return x1 * y2 - x2 * y1 + x2 * y3 - x3 * y2 + x3 * y1 - x1 * y3;
}

const ld eps = 1e-8;

template<class T>
struct point
{
	T x, y;

	point(const T& x = 0, const T& y = 0) : x(x), y(y) {}

	point& operator += (const point& p)
	{
		x += p.x;
		y += p.y;
		return *this;
	}
	point operator + (const point& p) const
	{
		return point(*this) += p;
	}

	point& operator -= (const point& p)
	{
		x -= p.x;
		y -= p.y;
		return *this;
	}
	point operator - (const point& p) const
	{
		return point(*this) -= p;
	}

	point& operator *= (const T& c)
	{
		x *= c;
		y *= c;
		return *this;
	}
	point operator * (const T& c) const
	{
		return point(*this) *= c;
	}

	point& operator /= (const T& c)
	{
		x /= c;
		y /= c;
		return *this;
	}
	point operator / (const T& c) const
	{
		return point(*this) /= c;
	}

	T norm() const
	{
		return sqrt(x * x + y * y);
	}

	T det(const point& p) const
	{
		return x * p.y - p.x * y;
	}
	friend T det(const point& p, const point& q)
	{
		return p.det(q);
	}
	friend T det(const point& p, const point& q, const point& r)
	{
		return (q - p).det(r - p);
	}

	T dot(const point& p) const
	{
		return x * p.x + y * p.y;
	}
	friend T dot(const point& p, const point& q)
	{
		return p.dot(q);
	}

	T dis(const point& p) const
	{
		return (*this - p).norm();
	}
	friend T dis(const point& p, const point& q)
	{
		return p.dis(q);
	}

	friend vector<point> circle_intersection(point p1, T r1, point p2, T r2)
	{
		T d = p1.dis(p2);
		if (d > r1 + r2 || d < abs(r1 - r2)) return {};
		T a = (r1 * r1 - r2 * r2 + d * d) / (2 * d);
		point p = (p2 - p1) / d;
		point q(-p.y, p.x);
		T b = sqrt(r1 * r1 - a * a);
		if (b == 0)
			return { p1 + p * a };
		else
			return { p1 + p * a + q * b, p1 + p * a - q * b };
	}
};

using pt = point<ld>;

int n, k;
pt p[MAXN];
ld c[MAXN], r[MAXN];

int calc(pt v)
{
	int ret = 0;
	for (int i = 1; i <= n; ++i)
	{
		if (p[i].dis(v) < r[i] + eps) ret++;
	}
	return ret;
}

bool check(ld m)
{
	for (int i = 1; i <= n; ++i)
	{
		r[i] = m / c[i];
	}
	for (int i = 1; i <= n; ++i)
	{
		if (calc(p[i]) >= k) return true;
		for (int j = i + 1; j <= n; ++j)
		{
			auto v = circle_intersection(p[i], r[i], p[j], r[j]);
			for (auto p : v)
			{
				if (calc(p) >= k) return true;
			}
		}
	}
	return false;
}

void solve()
{
	n = inp();
	k = inp();
	for (int i = 1; i <= n; ++i)
	{
		p[i].x = inp();
		p[i].y = inp();
		c[i] = inp();
	}
	
	ld L = 0, R = 1000000;
	ld ans = R;
	for (int i = 1; i <= 100; ++i)
	{
		ld m = (L + R) / 2;
		if (check(m))
		{
			ans = m;
			R = m;
		}
		else
			L = m;
	}

	printf("%.10f\n", ans);
}

int main()
{

	//for (int T = inp(); T --; )
	solve();

	return 0;
}

Measured memory_bytes: 384