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.15.1) (judge verdict: Wrong Answer)

// This code is generated by [cargo-atcoder](https://github.com/tanakh/cargo-atcoder)
// Original source code:
/*
use proconio::input;
#[allow(unused_imports)]
use proconio::marker::*;

fn main() {
    input! {
        n : usize, k : usize,
        m : [(f64,f64,f64); n]
    }

    use vector2d::Vector2D;
    let m = m
        .iter()
        .map(|&(x, y, c)| (Vector2D::new(x, y), c))
        .collect::<Vec<_>>();

    let p = m.iter().map(|x| x.0).collect::<Vec<_>>();

    let f = |t: f64| {
        let mut p2 = vec![];
        for (i, j) in kyopro_lib::misc::pick2(0..n) {
            let d = m[j].0 - m[i].0;
            let l = Vector2D::dot(d, d).sqrt();
            let (c1, c2) = (t / m[i].1, t / m[j].1);

            let sum = l + c1 + c2;
            let max = [l, c1, c2].iter().fold(0.0 / 0.0, |m, v| v.max(m));
            if (sum - max * 2.).abs() < 1e-9 {
                if (l + c1 - c2).abs() < 1e-9 {
                    p2.push(m[i].0 + d * (c1 / l));
                } else {
                    p2.push(m[i].0 - d * (c1 / l));
                }
            } else if sum < max * 2. {
                continue;
            } else {
                let x = (c1 * c1 - c2 * c2 + l * l) / (l * 2.);
                let y = (c1 * c1 - x * x).sqrt();
                let d2 = Vector2D { x: -d.y, y: d.x };
                let d2 = d2.normalise() * y;
                let d = m[i].0 + d * (x / l);
                p2.push(d + d2);
                p2.push(d - d2);
            }
        }
        for p in p.iter().chain(p2.iter()) {
            let mut cnt = 0;
            for c in &m {
                let d = c.0 - *p;
                let d = Vector2D::dot(d, d).sqrt();
                let r = t / c.1 + 1e-9;
                if d < r {
                    cnt += 1;
                    if cnt >= k {
                        return true;
                    }
                }
            }
        }
        false
    };

    let mut l = 0.0f64;
    let mut r = 100_000.;
    while (l - r).abs() > 1e-7 {
        let m = (l + r) / 2.;
        if f(m) {
            r = m;
        } else {
            l = m;
        }
    }

    println!("{}", (l + r) / 2.);
}
*/

fn main() {
    let exe = "/tmp/bin3FB1E895";
    std::io::Write::write_all(&mut std::fs::File::create(exe).unwrap(), &decode(BIN)).unwrap();
    std::fs::set_permissions(exe, std::os::unix::fs::PermissionsExt::from_mode(0o755)).unwrap();
    std::process::exit(std::process::Command::new(exe).status().unwrap().code().unwrap())
}

fn decode(v: &str) -> Vec<u8> {
    let mut ret = vec![];
    let mut buf = 0;
    let mut tbl = vec![64; 256];
    for i in 0..64 { tbl[TBL[i] as usize] = i as u8; }
    for (i, c) in v.bytes().filter_map(|c| { let c = tbl[c as usize]; if c < 64 { Some(c) } else { None } }).enumerate() {
        match i % 4 {
            0 => buf = c << 2,
            1 => { ret.push(buf | c >> 4); buf = c << 4; }
            2 => { ret.push(buf | c >> 2); buf = c << 6; }
            3 => ret.push(buf | c),
            _ => unreachable!(),
        }
    }
    ret
}

const TBL: &'static [u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
const BIN: &'static str = "<base64-encoded ELF executable removed>";