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 C++14 (GCC 5.4.1) (judge verdict: Wrong Answer)

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define For(i,n,k) for(ll i=(n);i<(k);i++)
#define ALL(a)  (a).begin(),(a).end()
random_device rnd;
double dist(double x,double y,double a,double b){
    return sqrt((x-a)*(x-a)+(y-b)*(y-b));
}
struct Niku{
    double x;
    double y;
    ll c;
};
void Main(){
    auto start = std::chrono::system_clock::now();
    ll n;cin>>n;
    ll k;cin>>k;
    vector<Niku> niku(n);
    For(i,0,n){
        cin>>niku[i].x>>niku[i].y>>niku[i].c;
    }
    pair<double,double> place;
    double mintime=1e10;
    for(double X=-1000;X<=1000.1;X+=5){
        for(double Y=-1000;Y<=1000.1;Y+=5){
            vector<double> time(n);
            For(i,0,n){
                time[i]=niku[i].c*dist(X,Y,niku[i].x,niku[i].y);
            }
            sort(ALL(time));
            if(time[k-1]<mintime){
                mintime=time[k-1];
                place=make_pair(X,Y);
            }
        }
    }
    for(double X=place.first-10;X<=place.first+10;X+=0.01){
        for(double Y=place.second-5;Y<=place.second+5;Y+=0.01){
            vector<double> time(n);
            For(i,0,n){
                time[i]=niku[i].c*dist(X,Y,niku[i].x,niku[i].y);
            }
            sort(ALL(time));
            if(time[k-1]<mintime){
                mintime=time[k-1];
                place=make_pair(X,Y);
            }
        }
    }
    for(double X=place.first-0.02;X<=place.first+0.02;X+=0.0002){
        for(double Y=place.second-0.02;Y<=place.second+0.02;Y+=0.0002){
            vector<double> time(n);
            For(i,0,n){
                time[i]=niku[i].c*dist(X,Y,niku[i].x,niku[i].y);
            }
            sort(ALL(time));
            if(time[k-1]<mintime){
                mintime=time[k-1];
                place=make_pair(X,Y);
            }
        }
    }
    for(double X=place.first-0.0002;X<=place.first+0.0002;X+=0.00001){
        for(double Y=place.second-0.0002;Y<=place.second+0.0002;Y+=0.00001){
            vector<double> time(n);
            For(i,0,n){
                time[i]=niku[i].c*dist(X,Y,niku[i].x,niku[i].y);
            }
            sort(ALL(time));
            if(time[k-1]<mintime){
                mintime=time[k-1];
                place=make_pair(X,Y);
            }
        }
    }
    double relx=0,rely=0;
    For(t,1,10000){
        mt19937 engine(rnd());
        uniform_real_distribution<> dist1(-0.0002, 0.0002);
        uniform_real_distribution<> dist2(-0.0002, 0.0002); 
        double d1=dist1(engine);
        double d2=dist2(engine);
        double xt=place.first+d1+relx;
        double yt=place.second+d2+rely;
        vector<double> time(n);
        For(i,0,n){
            time[i]=niku[i].c*dist(xt,yt,niku[i].x,niku[i].y);
        }   
        sort(ALL(time)); 
        if(time[k-1]<mintime){
            mintime=time[k-1];
            place=make_pair(xt,yt);
            relx=d1/double(t);
            rely=d2/double(t);
        }        
        else{
          relx=0;
          rely=0;
        }
    }
    cout<<fixed<<setprecision(10)<<mintime<<endl;    
}
int main(){
    Main();
    return 0;
}