Problem:
Score : 600 points

Problem Statement

Takahashi wants to grill N pieces of meat on a grilling net, which can be seen as a two-dimensional plane. The coordinates of the i-th piece of meat are \left(x_i, y_i\right), and its hardness is c_i.

Takahashi can use one heat source to grill the meat. If he puts the heat source at coordinates \left(X, Y\right), where X and Y are real numbers, the i-th piece of meat will be ready to eat in c_i \times \sqrt{\left(X - x_i\right)^2 + \left(Y-y_i\right)^2} seconds.

Takahashi wants to eat K pieces of meat. Find the time required to have K or more pieces of meat ready if he put the heat source to minimize this time.

Constraints

All values in input are integers.

1 \leq N \leq 60

1 \leq K \leq N

-1000 \leq x_i , y_i \leq 1000

\left(x_i, y_i\right) \neq \left(x_j, y_j\right) \left(i \neq j \right)

1 \leq c_i \leq 100

Input

Input is given from Standard Input in the following format:

N K
x_1 y_1 c_1
\vdots
x_N y_N c_N

Output

Print the answer.

It will be considered correct if its absolute or relative error from our answer is at most 10^{-6}.

Sample Input 1

4 3
-1 0 3
0 0 3
1 0 2
1 1 40

Sample Output 1

2.4

If we put the heat source at \left(-0.2, 0\right), the 1-st, 2-nd, and 3-rd pieces of meat will be ready to eat within 2.4 seconds. This is the optimal place to put the heat source.

Sample Input 2

10 5
-879 981 26
890 -406 81
512 859 97
362 -955 25
128 553 17
-885 763 2
449 310 57
-656 -204 11
-270 76 40
184 170 16

Sample Output 2

7411.2252

Solution in Kotlin (1.0.0) (judge verdict: Accepted)

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))
        )
    )
}