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 Rust (1.42.0) (judge verdict: Accepted)

use std::cmp;

const EPS: f64 = 1e-9;

fn main () {
    let (n, k): (usize, usize) = {
        let mut buf = String::new();
        std::io::stdin().read_line(&mut buf).unwrap();
        let mut iter = buf.split_whitespace();
        (
            iter.next().unwrap().parse().unwrap(),
            iter.next().unwrap().parse().unwrap(),
        )
    };

    let mut x: Vec<f64> = vec![0.0; n];
    let mut y: Vec<f64> = vec![0.0; n];
    let mut c: Vec<f64> = vec![0.0; n];
    for i in 0..n {
        let mut buf = String::new();
        std::io::stdin().read_line(&mut buf).unwrap();
        let mut iter = buf.split_whitespace();
        x[i] = iter.next().unwrap().parse().unwrap();
        y[i] = iter.next().unwrap().parse().unwrap();
        c[i] = iter.next().unwrap().parse().unwrap();
    }

    let mut left: f64 = 0.0;
    let mut right: f64 = 200_000.0;
    while EPS < right - left {
        let t: f64 = (left + right) / 2.0;

        let count = |p: f64, q: f64| -> usize {
            let mut cnt: usize = 0;
            for i in 0..n {
                let r = t / c[i];
                if (p - x[i]).hypot(q - y[i]) <= r + EPS {
                    cnt += 1;
                }
            }
            cnt
        };

        let mut res: usize = 0;

        for i in 0..n {
            res = cmp::max(res, count(x[i], y[i]));
        }

        for i in 0..n {
            for j in (i + 1)..n {
                let r1 = t / c[i];
                let r2 = t / c[j];

                if (x[i] - x[j]).hypot(y[i] - y[j]) > r1 + r2 {
                    continue;
                }
                if (x[i] - x[j]).hypot(y[i] - y[j]) < (r1 - r2).abs() {
                    continue;
                }

                let a = 2.0 * (x[j] - x[i]);
                let b = 2.0 * (y[j] - y[i]);
                let c = {
                    x[i].powi(2) - x[j].powi(2) +
                    y[i].powi(2) - y[j].powi(2) +
                    r2.powi(2) - r1.powi(2)
                };    
                let d = (a * x[i] + b * y[i] + c).abs();
                let aa = a.powi(2);
                let bb = b.powi(2);
                let dd = d.powi(2);
                let rr1 = r1.powi(2);
    
                let p = (a * d - b * ((aa + bb) * rr1 - dd).sqrt()) / (aa + bb) + x[i];
                let q = (b * d + a * ((aa + bb) * rr1 - dd).sqrt()) / (aa + bb) + y[i];
                res = cmp::max(res, count(p, q));
    
                let p = (a * d + b * ((aa + bb) * rr1 - dd).sqrt()) / (aa + bb) + x[i];
                let q = (b * d - a * ((aa + bb) * rr1 - dd).sqrt()) / (aa + bb) + y[i];
                res = cmp::max(res, count(p, q));    
            }
        }

        if res < k {
            left = t;
        } else {
            right = t;
        }
    }
    println!("{:.10}", right);
}