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


Measured memory_bytes: 512