import java.lang.Math

data class Point(val x: Double, val y: Double) {
    companion object {
        // 外積
        fun cross(a: Point, b: Point) = a.x * b.y - a.y * b.x
    }

    operator fun unaryMinus() = Point(-x, -y)
    operator fun inc() = Point(x + 1.0, y + 1.0)
    operator fun dec() = Point(x - 1.0, y - 1.0)
    operator fun plus(inc: Point) = Point(x + inc.x, y + inc.y)
    operator fun minus(dec: Point) = Point(x - dec.x, y - dec.y)
    operator fun times(mul: Double) = Point(x * mul, y * mul)
    operator fun div(div: Double) = Point(x / div, y / div)

    // ノルム(≒絶対値の2乗)
    fun norm() = x * x + y * y

    // 絶対値
    fun abs() = Math.sqrt(norm())
}
operator fun Double.times(p: Point) = Point(toDouble() * p.x, toDouble() * p.y)
data class Circle(val p: Point, val r: Double)

fun main(args: Array<String>) {
    val (N, K) = readInputLine().split(" ").map { it.toInt() }
    val points = Array(N) { val (x, y, c) = readInputLine().split(" ").map { it.toDouble() }; Pair(Point(x, y), c) }

    var l = 0.0
    var r = 100.0 * Math.sqrt(2000.0 * 2000.0 + 2000.0 * 2000.0)
    val eps = 0.0000001

    while (r - l > eps) {
        val m = (r + l) / 2.0

        var ok = false

        // 円の中心に関する調査
        for ((i1, m1) in points.withIndex()) {
            val (p1, c1) = m1
            var cnt = 1
            for ((i2, m2) in points.withIndex()) {
                if (i1 == i2) {
                    continue
                }
                val (p2, c2) = m2
                if ((p2 - p1).abs() - m / c2 < eps) {
                    cnt++
                    if (cnt >= K) {
                        break
                    }
                }
            }
            if (cnt >= K) {
                ok = true
                break
            }
        }
        if (ok) {
            r = m
            continue
        }

        // 円の交点に関する調査
        for ((i1, m1) in points.withIndex()) {
            val (p1, c1) = m1
            for ((i2, m2) in points.withIndex()) {
                if (i1 == i2) {
                    continue
                }
                val (p2, c2) = m2
                val (hasInt, ints) = getIntersections(Circle(p1, m / c1), Circle(p2, m / c2))
                if (!hasInt) {
                    continue
                }
                var cnt = 0
                for ((p3, c3) in points) {
                    if ((ints.first - p3).abs() - m / c3 < eps) {
                        cnt++
                        if (cnt >= K) {
                            break
                        }
                    }
                }
                if (cnt >= K) {
                    ok = true
                    break
                }
                cnt = 0
                for ((p3, c3) in points) {
                    if ((ints.second - p3).abs() - m / c3 < eps) {
                        cnt++
                        if (cnt >= K) {
                            break
                        }
                    }
                }
                if (cnt >= K) {
                    ok = true
                    break
                }
            }
            if (ok) {
                break
            }
        }
        if (ok) {
            r = m
        } else {
            l = m
        }
    }

    println(l)
}

fun readInputLine(): String {
    return readLine()!!
}

fun getIntersections(c1: Circle, c2: Circle): Pair<Boolean, Pair<Point, Point>> {
    val d = Math.sqrt((c2.p.x - c1.p.x) * (c2.p.x - c1.p.x) + (c2.p.y - c1.p.y) * (c2.p.y - c1.p.y))
    if (d > c1.r + c2.r) {
        return Pair(false, Pair(Point(0.0, 0.0), Point(0.0, 0.0)))
    }

    val theta = Math.atan2(c2.p.y - c1.p.y, c2.p.x - c1.p.x)
    val alpha = Math.acos((d * d + c1.r * c1.r - c2.r * c2.r) / (2.0 * d * c1.r))

    return Pair(true,
        Pair(
            Point(c1.p.x + c1.r * Math.cos(theta + alpha), c1.p.y + c1.r * Math.sin(theta + alpha)),
            Point(c1.p.x + c1.r * Math.cos(theta - alpha), c1.p.y + c1.r * Math.sin(theta - alpha))
        )
    )
}


Measured memory_bytes: 63620