// Slower C++ solution:
#include <bits/stdc++.h>



#define rep(i, n) for (int i = 0; i < int(n); i++)

#define rrep(i, n) for (int i = int(n) - 1; i >= 0; i--)

#define reps(i, n) for (int i = 1; i <= int(n); i++)

#define rreps(i, n) for (int i = int(n); i >= 1; i--)

#define repc(i, n) for (int i = 0; i <= int(n); i++)

#define rrepc(i, n) for (int i = int(n); i >= 0; i--)

#define repi(i, a, b) for (int i = int(a); i < int(b); i++)

#define repic(i, a, b) for (int i = int(a); i <= int(b); i++)

#define all(a) (a).begin(), (a).end()

#define bit32(x) (1 << (x))

#define bit64(x) (1ll << (x))

#define sz(v) ((int) v.size())



using namespace std;



using i64 = long long;

using f80 = long double;

using vi32 = vector<int>;

using vi64 = vector<i64>;

using vf80 = vector<f80>;

using vstr = vector<string>;



inline void yes() { cout << "Yes" << endl; exit(0); }

inline void no() { cout << "No" << endl; exit(0); }

inline i64 gcd(i64 a, i64 b) { if (min(a, b) == 0) return max(a, b); if (a % b == 0) return b; return gcd(b, a % b); }

inline i64 lcm(i64 a, i64 b) { if (min(a, b) == 0) return max(a, b); return a / gcd(a, b) * b; }

template <typename T> class pqasc : public priority_queue<T, vector<T>, greater<T>> {};

template <typename T> class pqdesc : public priority_queue<T, vector<T>, less<T>> {};

template <typename T> inline void amax(T &x, T y) { x = max(x, y); }

template <typename T> inline void amin(T &x, T y) { x = min(x, y); }

template <typename T> inline T exp(T x, i64 n, T e = 1) { T r = e; while (n > 0) { if (n & 1) r *= x; x *= x; n >>= 1; } return r; }

template <typename T> istream& operator>>(istream &is, vector<T> &v) { for (auto &x : v) is >> x; return is; }

template <typename T> ostream& operator<<(ostream &os, vector<T> &v) { rep(i, v.size()) { if (i) os << ' '; os << v[i]; } return os; }

void solve(); int main() { ios::sync_with_stdio(0); cin.tie(0); cout << fixed << setprecision(16); solve(); return 0; }



template <typename T>

struct Vec2 {

  T x, y;

  Vec2() : x(0), y(0) {}

  Vec2(T x, T y) : x(x), y(y) {}

  Vec2& operator+=(Vec2 that) { x += that.x, y += that.y; return *this; }

  Vec2& operator-=(Vec2 that) { x -= that.x, y -= that.y; return *this; }

  Vec2& operator*=(T s) { x *= s, y *= s; return *this; }

  Vec2& operator/=(T s) { x /= s, y /= s; return *this; }

  T dot(Vec2 that) { return x * that.x + y * that.y; }

  T cross(Vec2 that) { return x * that.y - y * that.x; }

  Vec2 operator+(Vec2 that) { return Vec2(*this) += that; }

  Vec2 operator-(Vec2 that) { return Vec2(*this) -= that; }

  Vec2 operator*(T that) { return Vec2(*this) *= that; }

  Vec2 operator/(T that) { return Vec2(*this) /= that; }

  T length() { return sqrt(pow(x, 2) + pow(y, 2)); }

  Vec2 normal() { return Vec2(*this) / (*this).length(); }

  friend ostream& operator<<(ostream &os, Vec2 m) { return os << "(" << m.x << ", " << m.y << ")"; }

};



const f80 eps = 1e-9;



template <typename T>

struct Circle {

  Vec2<T> p;

  T r;

  Circle() : p(), r(0) {}

  Circle(Vec2<T> p, T r) : p(p), r(r) {}

  vector<Vec2<T>> cross(Circle a) {

    auto n = (a.p - p).normal();

    auto d = (a.p - p).length();

    if (abs(d - abs(a.r - r)) < eps || abs(r + a.r - d) < eps) {

      return vector<Vec2<T>>({ p + n * r });

    }

    if (d - abs(a.r - r) < eps || r + a.r - d < eps) {

      return vector<Vec2<T>>();

    }

    T rc = (d * d + r * r - a.r * a.r) / (d * 2);

    T rs = sqrt(r * r - rc * rc);

    return vector<Vec2<T>>({

      p + n * rc + Vec2<f80>(n.y, -n.x) * rs,

      p + n * rc + Vec2<f80>(-n.y, n.x) * rs,

    });

  }

};



void solve() {

  int n, k;

  cin >> n >> k;

  vf80 x(n), y(n), c(n);

  rep(i, n) {

    cin >> x[i] >> y[i] >> c[i];

  }

  using P = pair<f80, f80>;

  f80 ok = 1e18, ng = 0;

  rep(_, 100) {

    f80 t = (ok + ng) / 2;

    vector<P> target;

    rep(i, n) {

      target.emplace_back(x[i], y[i]);

    }

    rep(i, n) rep(j, i) {

      auto a = Circle<f80>(Vec2<f80>(x[i], y[i]), t / c[i]);

      auto b = Circle<f80>(Vec2<f80>(x[j], y[j]), t / c[j]);

      for (auto v : a.cross(b)) {

        target.emplace_back(v.x, v.y);

      }

    }

    int cnt = 0;

    for (auto v : target) {

      int co = 0;

      Vec2<f80> u(v.first, v.second);

      rep(i, n) {

        Vec2<f80> v(x[i], y[i]);

        if ((u - v).length() - t / c[i] <= eps) co++;

      }

      amax(cnt, co);

    }

    (cnt >= k ? ok : ng) = t;

  }

  cout << ok << endl;

}


// Faster C++ solution for the same problem (measured speedup: 2.2057186238179636x):
#include <bits/stdc++.h>



#define rep(i, n) for (int i = 0; i < int(n); i++)

#define rrep(i, n) for (int i = int(n) - 1; i >= 0; i--)

#define reps(i, n) for (int i = 1; i <= int(n); i++)

#define rreps(i, n) for (int i = int(n); i >= 1; i--)

#define repc(i, n) for (int i = 0; i <= int(n); i++)

#define rrepc(i, n) for (int i = int(n); i >= 0; i--)

#define repi(i, a, b) for (int i = int(a); i < int(b); i++)

#define repic(i, a, b) for (int i = int(a); i <= int(b); i++)

#define all(a) (a).begin(), (a).end()

#define bit32(x) (1 << (x))

#define bit64(x) (1ll << (x))

#define sz(v) ((int) v.size())



using namespace std;



using i64 = long long;

using f80 = long double;

using vi32 = vector<int>;

using vi64 = vector<i64>;

using vf80 = vector<f80>;

using vstr = vector<string>;



inline void yes() { cout << "Yes" << endl; exit(0); }

inline void no() { cout << "No" << endl; exit(0); }

inline i64 gcd(i64 a, i64 b) { if (min(a, b) == 0) return max(a, b); if (a % b == 0) return b; return gcd(b, a % b); }

inline i64 lcm(i64 a, i64 b) { if (min(a, b) == 0) return max(a, b); return a / gcd(a, b) * b; }

template <typename T> class pqasc : public priority_queue<T, vector<T>, greater<T>> {};

template <typename T> class pqdesc : public priority_queue<T, vector<T>, less<T>> {};

template <typename T> inline void amax(T &x, T y) { x = max(x, y); }

template <typename T> inline void amin(T &x, T y) { x = min(x, y); }

template <typename T> inline T exp(T x, i64 n, T e = 1) { T r = e; while (n > 0) { if (n & 1) r *= x; x *= x; n >>= 1; } return r; }

template <typename T> istream& operator>>(istream &is, vector<T> &v) { for (auto &x : v) is >> x; return is; }

template <typename T> ostream& operator<<(ostream &os, vector<T> &v) { rep(i, v.size()) { if (i) os << ' '; os << v[i]; } return os; }

void solve(); int main() { ios::sync_with_stdio(0); cin.tie(0); cout << fixed << setprecision(16); solve(); return 0; }



struct Vec2 {

  double x, y;

  Vec2() : x(0), y(0) {}

  Vec2(double x, double y) : x(x), y(y) {}

  Vec2& operator+=(Vec2 that) { x += that.x, y += that.y; return *this; }

  Vec2& operator-=(Vec2 that) { x -= that.x, y -= that.y; return *this; }

  Vec2& operator*=(double s) { x *= s, y *= s; return *this; }

  Vec2& operator/=(double s) { x /= s, y /= s; return *this; }

  double dot(Vec2 that) { return x * that.x + y * that.y; }

  double cross(Vec2 that) { return x * that.y - y * that.x; }

  Vec2 operator+(Vec2 that) { return Vec2(*this) += that; }

  Vec2 operator-(Vec2 that) { return Vec2(*this) -= that; }

  Vec2 operator*(double that) { return Vec2(*this) *= that; }

  Vec2 operator/(double that) { return Vec2(*this) /= that; }

  double length() { return sqrt(pow(x, 2) + pow(y, 2)); }

  Vec2 normal() { return Vec2(*this) / (*this).length(); }

  friend ostream& operator<<(ostream &os, Vec2 m) { return os << "(" << m.x << ", " << m.y << ")"; }

};



const double eps = 1e-9;



struct Circle {

  Vec2 p;

  double r;

  Circle() : p(), r(0) {}

  Circle(Vec2 p, double r) : p(p), r(r) {}

  vector<Vec2> cross(Circle a) {

    auto n = (a.p - p).normal();

    auto d = (a.p - p).length();

    if (abs(d - abs(a.r - r)) < eps || abs(r + a.r - d) < eps) {

      return vector<Vec2>({ p + n * r });

    }

    if (d - abs(a.r - r) < eps || r + a.r - d < eps) {

      return vector<Vec2>();

    }

    double rc = (d * d + r * r - a.r * a.r) / (d * 2);

    double rs = sqrt(r * r - rc * rc);

    return vector<Vec2>({

      p + n * rc + Vec2(n.y, -n.x) * rs,

      p + n * rc + Vec2(-n.y, n.x) * rs,

    });

  }

};



void solve() {

  int n, k;

  cin >> n >> k;

  vector<double> x(n), y(n), c(n);

  rep(i, n) {

    cin >> x[i] >> y[i] >> c[i];

  }

  using P = pair<double, double>;

  double ok = 1e18, ng = 0;

  rep(_, 100) {

    double t = (ok + ng) / 2;

    vector<P> target;

    rep(i, n) {

      target.emplace_back(x[i], y[i]);

    }

    rep(i, n) rep(j, i) {

      auto a = Circle(Vec2(x[i], y[i]), t / c[i]);

      auto b = Circle(Vec2(x[j], y[j]), t / c[j]);

      for (auto v : a.cross(b)) {

        target.emplace_back(v.x, v.y);

      }

    }

    int cnt = 0;

    for (auto v : target) {

      int co = 0;

      Vec2 u(v.first, v.second);

      rep(i, n) {

        Vec2 v(x[i], y[i]);

        if ((u - v).length() - t / c[i] <= eps) co++;

      }

      amax(cnt, co);

    }

    (cnt >= k ? ok : ng) = t;

  }

  cout << ok << endl;

}