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: Accepted)

// 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::*;

use vector2d::Vector2D;
#[derive(Copy, Clone)]
struct Circle(Vector2D<f64>, f64);

fn is_inside(c: &Circle, p: &Vector2D<f64>) -> bool {
    let d = c.0 - *p;
    let r = c.1 + 1e-9;
    d.length_squared() < r * r
}
fn cross_point(c1: &Circle, c2: &Circle) -> Vec<Vector2D<f64>> {
    let eq = |x: f64, y: f64| (x - y).abs() < 1e-9;

    let d = c2.0 - c1.0;
    let l = d.length();
    if eq(l, 0.) {
        return vec![];
    }
    let sum = l + c1.1 + c2.1;
    let max = [l, c1.1, c2.1].iter().fold(0. / 0., |m, v| v.max(m));
    if eq(sum, max * 2.) {
        if eq(l + c1.1, c2.1) {
            return vec![c1.0 - d * c1.1 / l];
        } else {
            return vec![c1.0 + d * c1.1 / l];
        }
    }
    if sum < max * 2. {
        return vec![];
    }
    let x = (l * l + c1.1 * c1.1 - c2.1 * c2.1) / (l * 2.);
    let y = (c1.1 * c1.1 - x * x).sqrt();
    let d = d.normalise();
    let mid = c1.0 + d * x;
    let v = d.normal() * y;
    vec![mid + v, mid - v]
}

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

    let m = m
        .iter()
        .map(|&(x, y, c)| Circle(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 c1 = Circle(m[i].0, t / m[i].1);
            let c2 = Circle(m[j].0, t / m[j].1);
            p2.append(&mut cross_point(&c1, &c2));
        }
        for p in p.iter().chain(p2.iter()) {
            let mut cnt = 0;
            for c in &m {
                let mut c = *c;
                c.1 = t / c.1;
                if is_inside(&c, p) {
                    cnt += 1;
                    if cnt >= k {
                        return true;
                    }
                }
            }
        }
        false
    };

    let mut l = 0.0f64;
    let mut r = 1000_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/binEFBDE974";
    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>";