#include <iostream>
#include <queue>
#include <cmath>
using namespace std;

struct dot
{
    int x;
    int y;
    double center;
};

void simpleSort(dot* dots, int l, int r)
{
    dot buff;
    int j;

    for (int i = l + 1; i < r + 1; ++i)
    {
        j = i;
        while (j > l && dots[j - 1].center > dots[j].center)
        {
            buff = dots[j - 1];
            dots[j - 1] = dots[j];
            dots[j] = buff;
            j--;
        }
    }
}

void merge(dot* dots, int l, int mid, int r)
{
    int ls = 0, rs = 0;
    dot result[r - l + 1];

    {
        while ((l + ls < mid + 1) && (mid + rs < r))
        {
            if (dots[l + ls].center < dots[mid + rs + 1].center)
            {
                result[ls + rs] = dots[l + ls];
                ls++;
            }
            else
            {
                result[ls + rs] = dots[mid + 1 + rs];
                rs++;
            }
        }
    }
}

void mergeSort(dot* dots, int l, int r)
{
    if (r - l <= 1)
        return;

    if ((r - l) < 12)
    {
        simpleSort(dots, l, r);
        return;
    }

    int mid = (l + r) / 2;
    mergeSort(dots, l, mid);
    mergeSort(dots, mid + 1, r);
    merge(dots, l, mid, r);
}


bool is_contain_k(double radius, dot* dots, int n, int k)
{

    std::queue<int> dots_in_disk;
    int count;
    double center;
    double x_, diff;
    double left;

    int centers[n];
    for (int i = 0; i < n; ++i)
    {
        center = -5000;
        if ((radius * radius - dots[i].y * dots[i].y) >= 0)
        {

            x_ = sqrt(radius * radius - dots[i].y * dots[i].y) + center;
            diff = dots[i].x - x_;
            center += diff;
            dots[i].center = center;
        }
        else
        {
            cout << "точка выше ниже окр" << (radius * radius) << " " << dots[i].y * dots[i].y
                 << endl;
            dots[i].center = 5000;
        }
    }
    mergeSort(dots, 0, n - 1);

    if (radius < 6)
    {
        cout << "Координаты центров окр при радиусе " << radius << endl;
        for (int i = 0; i < n; ++i)
            cout << dots[i].center << " ";
        cout << endl << endl;
    }

    dots_in_disk.push(0);
    count = 1;
    double x, y;
    for (int i = 1; i < n; ++i)
    {
        if (dots[i].center < 1000 + radius)
        {
            diff = dots[i].center - center;
            left = center - radius;
            x = dots[dots_in_disk.front()].x;
            y = dots[dots_in_disk.front()].y;

            while (
                count > 0 && ((x - center - diff) * (x - center - diff) + y * y > radius * radius))
            {
                count--;
                dots_in_disk.pop();
                x = dots[dots_in_disk.front()].x;
                y = dots[dots_in_disk.front()].y;
            }
            center += diff;
            left += diff;
            dots_in_disk.push(i);
            count++;

            if (count == k)
            {
                if (radius < 6)
                    std::cout << "Прошло, центр:" << center << std::endl;
                return true;
            }
        }
    }
    return false;
}

double binary_search(dot* dots, int n, int k)
{
    double max_r = 1420;
    double min_r = 0;
    double radius;

    while (max_r - min_r > 1e-4 && max_r >= min_r)
    {
        radius = (max_r + min_r) / 2;
        cout << "aa------------------------aa" << endl;
        if (is_contain_k(radius, dots, n, k))
        {
            max_r = radius;
            if (max_r < 8)
            {
                std::cout << "прошолло обновлённое значение min_r,max_r"
                          << "  " << min_r << "  " << max_r << " \n";
                cout << "bb------------------------bb" << endl;
            }
        }
        else
        {
            min_r = radius + 1e-4;
        }
    }

    return max_r;
}

int main()
{
    int n, k;

    /*
    std::cin >> n;
    std::cin >> k;
    dot dots[n] = {};
    for (int i=0; i <n; ++i) {
        std::cin >> dots[i].x;
        std::cin >> dots[i].y;
    }
    */
    cout << "dsf";
    dot dots[n] = { { 0, 1 }, { 2, 1 } };
    // dot dots[n] = { { 0, 5 }, { 3, 4 }, { -4, -3 } };
    n = 2;
    k = 2;
    // double radius = 6;

    double res = binary_search(dots, n, k);
    std::cout << res;

    return 0;
}