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::{fastout, input};
use rand::prelude::*;
use std::collections::BinaryHeap;
use std::time::Instant;

const C: usize = 30;

#[derive(Debug, PartialEq, PartialOrd)]
struct Cmp<T>(pub T);

impl<T: PartialEq> Eq for Cmp<T> {}

impl<T: PartialOrd> Ord for Cmp<T> {
    fn cmp(&self, other: &Cmp<T>) -> std::cmp::Ordering {
        self.0.partial_cmp(&other.0).unwrap()
    }
}

#[derive(Debug)]
struct Pos {
    x: f64,
    y: f64,
    t: f64,
    r: f64,
}

fn set_time(cands: &mut Pos, in_xyc: &Vec<Vec<f64>>, in_k: usize) {
    let mut queue = BinaryHeap::new();

    for xyc in in_xyc.iter() {
        let x = cands.x - xyc[0];
        let y = cands.y - xyc[1];
        let t = (x * x + y * y).sqrt() * xyc[2];

        queue.push(Cmp(t));

        if queue.len() > in_k {
            queue.pop();
        }
    }

    cands.t = queue.pop().unwrap().0;
}

#[fastout]
fn main() {
    input! {in_n: usize, in_k: usize, in_xyc: [[f64; 3]; in_n]};
    let start = Instant::now();
    let mut cands = Vec::new();
    let mut mint = 1e+9;
    let mut rng = rand::thread_rng();

    for xyc in &in_xyc {
        cands.push(Pos {
            x: xyc[0],
            y: xyc[1],
            t: 1e+9,
            r: 500.0,
        });
    }

    for i in 0..cands.len() {
        set_time(&mut cands[i], &in_xyc, in_k);
    }

    loop {
        let elapsed = start.elapsed();

        if elapsed.as_millis() > 1900 {
            break;
        }

        let mut ncs = Vec::new();

        for c in &cands {
            for _ in 0..C {
                let rx = rng.gen::<f64>() * 2.0 - 1.0;
                let ry = rng.gen::<f64>() * 2.0 - 1.0;

                ncs.push(Pos {
                    x: c.x + c.r * rx,
                    y: c.y + c.r * ry,
                    t: c.t,
                    r: c.r,
                });
            }
        }

        for i in 0..ncs.len() {
            set_time(&mut ncs[i], &in_xyc, in_k);
        }

        for i in 0..cands.len() {
            let mut m = i * C;

            for j in m + 1..m + C {
                if ncs[j].t < ncs[m].t {
                    m = j;
                }
            }

            if ncs[m].t < cands[i].t {
                cands[i].x = ncs[m].x;
                cands[i].y = ncs[m].y;
                cands[i].t = ncs[m].t;
            }

            cands[i].r *= 0.98;
        }

        for c in &cands {
            if c.t < mint {
                mint = c.t;
            }
        }
    }

    println!("{}", mint);
}
*/

fn main() {
    let exe = "/tmp/binE86A4816";
    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>";