#include<iostream>
#include<cmath>
#include<vector>
#include<algorithm>
#include<iomanip>

using namespace std;

namespace v2d {

	struct Vec2 {
		//2次元ベクトルのクラス

		double x, y;
		Vec2(double _x, double _y) {
			x = _x, y = _y;
		}
		Vec2() {
			x = 0, y = 0;
		}

		Vec2 operator+() const {
			return *this;
		}
		Vec2 operator-() const {
			return{ -x, -y };
		}
		Vec2 operator+ (const Vec2& b) const {
			return{ x + b.x, y + b.y };
		}
		Vec2 operator- (const Vec2& b) const {
			return{ x - b.x, y - b.y };
		}
		Vec2 operator* (const double b) const {
			return{ x * b, y * b };
		}
		Vec2 operator/ (const double b) const {
			return{ x / b, y / b };
		}
		Vec2 operator+= (const Vec2& b) {
			x += b.x, y += b.y;
			return *this;
		}
		Vec2 operator-= (const Vec2& b) {
			x -= b.x, y -= b.y;
			return *this;
		}
		Vec2 operator*= (const double b) {
			x *= b, y *= b;
			return *this;
		}
		Vec2 operator/= (const double b) {
			x /= b, y /= b;
			return *this;
		}
		bool operator== (const Vec2& b) {
			return b.x == x && b.y == y;
		}

		double lengthSquare() {
			return (x * x + y * y);
		}
		double length() {
			return std::sqrt(lengthSquare());
		}
		double dot(const Vec2& b) {
			return x * b.x + y * b.y;
		}
		double cross(const Vec2& b) {
			//Generally, cross product is vector, but in 2D, cross product is also scalar.
			return x * b.y - y * b.x;
		}
		double distanceFrom(const Vec2& b) {
			return std::sqrt((x - b.x) * (x - b.x) + (y - b.y) * (y - b.y));
		}
		Vec2 normalized() {
			return{ x / length(), y / length() };
		}
		bool isZero() {
			return x == 0.0 && y == 0.0;
		}
		//単位法線ベクトル
		Vec2 normalUnitVector() {
			return {-normalized().y, normalized().x};
		}
	};

	inline Vec2 operator*(double a, const Vec2& b) {
		return{ b.x * a, b.y * a };
	}

	template <class Char>
	inline std::basic_ostream<Char>& operator <<(std::basic_ostream<Char>& os, const Vec2& v)
	{
		return os << Char('(') << v.x << Char(',') << v.y << Char(')');
	}

	template <class Char>
	inline std::basic_istream<Char>& operator >> (std::basic_istream<Char>& is, Vec2& v)
	{
		return is >> v.x >> v.y;
	}

	//eps　浮動小数点誤差
	const double EPS = 1e-10;

	//幾何ライブラリにおいて、解なしのような状態の時に返される点の値
	const Vec2 error_val = { 114514.0, -191981.0 };

	//a > 0ならば+1, a == 0ならば0, a < 0ならば-1　を返す。　基本的にEPS込みの評価はこれで行う。
	//不等式は、加減算に直してこれに適用する。
	int sgn(const double a) {
		return (a < -EPS ? -1 : (a > EPS ? +1 : 0));
	}
	
	inline bool operator==(const Vec2& a, const Vec2& b) {
		return (sgn(a.x - b.x) == 0 && sgn(a.y - b.y) == 0);
	}

}

namespace circle_2d {
	//交点が存在しないのなら、make_pair(error_val, error_val);を返す
	pair<v2d::Vec2, v2d::Vec2> crossPointInCircle(v2d::Vec2 p1, double r1, v2d::Vec2 p2, double r2) {
		
		if (p1 == p2)return make_pair(v2d::error_val, v2d::error_val);

		//完全に内包関係にある場合
		if (v2d::sgn(abs(r1 - r2) - (p1 - p2).length()) == 1)
			return make_pair(v2d::error_val, v2d::error_val);

		//p1中心の円を原点として考えることで、コーディング量が減る。

		v2d::Vec2 fp = p2 - p1;
		double fC = (pow(r1, 2) - pow(r2, 2) + fp.lengthSquare()) / 2.0;
		v2d::Vec2 ret1, ret2;

		if (v2d::sgn(fp.y) == 0) {
			//yをxの式で表す関係上、fp.yで割る必要があるので、fp.y==0ならば例外処理をする。
			ret1.x = fC / fp.x, ret2.x = fC / fp.x;
			ret1.y = sqrt(max(0.0, pow(r1, 2) - pow(ret1.x, 2)));
			ret2.y = -sqrt(max(0.0, pow(r1, 2) - pow(ret1.x, 2)));
			ret1 += p1, ret2 += p1;
			return make_pair(ret1, ret2);
		}
		else {

			//これは、交点を持たないとき
			if (v2d::sgn(pow(fp.x * fC, 2) - fp.lengthSquare() * (pow(fC, 2) - pow(fp.y * r1, 2))) == -1) {
				return make_pair(v2d::error_val, v2d::error_val);
			}

			ret1.x = (fp.x * fC + sqrt(pow(fp.x * fC, 2) - fp.lengthSquare() * (pow(fC, 2) - pow(fp.y * r1, 2))))
				/ fp.lengthSquare();
			ret2.x = (fp.x * fC - sqrt(pow(fp.x * fC, 2) - fp.lengthSquare() * (pow(fC, 2) - pow(fp.y * r1, 2))))
				/ fp.lengthSquare();
			ret1.y = (fC - fp.x * ret1.x) / fp.y;
			ret2.y = (fC - fp.x * ret2.x) / fp.y;
			ret1 += p1, ret2 += p1;
			return make_pair(ret1, ret2);
		}

	}
}

using namespace v2d;
using namespace circle_2d;

int N, K;
vector<Vec2> pos;
vector<double> c;

bool f(long double t) {
	//t秒以下でK枚の肉を焼きあげることができるか？
	for (int i = 0; i < N; i++) {
		for (int j = 0; j < N; j++) {
			if (i == j)continue;
			//円iと円jの交点を求める。

			//そもそも離れすぎて交点を持ってない。
			if (sgn(pos[i].distanceFrom(pos[j]) - (1.0 / c[i] + 1.0 / c[j]) * t) == 1) continue;

			//2つの交点の座標。1点でしか交わらなくても、cpos1とcpos2が同じになるだけなので実装上まとめる。
			auto tmp = crossPointInCircle(pos[i], t / c[i], pos[j], t / c[j]);
			if (tmp == make_pair(error_val, error_val))continue;//交わってない

			int cnt = 0;
			for (int k = 0; k < N; k++) {
				if (sgn(t / c[k] - tmp.first.distanceFrom(pos[k])) >= 0)
					cnt++;
			}

			if (cnt >= K)return true;

			cnt = 0;
			for (int k = 0; k < N; k++) {
				if (sgn(t / c[k] - tmp.second.distanceFrom(pos[k])) >= 0)
					cnt++;
			}
			if (cnt >= K)return true;

		}
	}

	//包含されてる場合、円の中心も答え候補になりうる
	for (int i = 0; i < N; i++) {
		int cnt = 1;
		for (int j = 0; j < N; j++) {
			if (i == j)continue;
			if (sgn(t / c[j] - pos[i].distanceFrom(pos[j])) == 1)cnt++;
		}
		if (cnt >= K)return true;
	}
	return false;
}

int main() {

	cin >> N >> K;
	pos.resize(N), c.resize(N);
	for (int i = 0; i < N; i++) {
		cin >> pos[i] >> c[i];
	}

	if (K == 1) {
		cout << 0 << endl;
		return 0;
	}

	long double ok = 1145141.0, ng = 0.0;
	while (ok - ng > 1e-9) {
		long double mid = (ok + ng) / 2.0;
		if (f(mid))ok = mid;
		else ng = mid;
	}
	cout << setprecision(10) << ok << endl;
	return 0;
}


Measured memory_bytes: 256