huita

#include <iostream>
#include <vector>
#include <cmath>
#include <algorithm>
#include <iomanip>

void CalculateCircumference(int point_min_count, std::vector<std::vector<int>> points,
                            int point_array_size) {
    float rad_H = 1100;
    float rad_L = 0;
    float mid;
    bool covers = true;

    std::vector<std::vector<float>> events;

    float right;
    float left;
    int point_cover_count = 0;
    int max_point_cover_count = 0;

    int events_size = 0;

    for (int iter = 0; iter < 40; ++iter) {
        mid = rad_L + (rad_H - rad_L) / 2.0;

        for (int iter = 0; iter < point_array_size; ++iter) {
            if (std::fabs(points[iter][1]) <= mid) {
                left = points[iter][0] - sqrt(pow(mid, 2) - pow(points[iter][1], 2));
                right = points[iter][0] + sqrt(pow(mid, 2) - pow(points[iter][1], 2));
                events.push_back({left, +1});
                events.push_back({right, -1});
            }
        }

        std::sort(events.begin(), events.end());
        events_size = static_cast<int>(events.size());

        for (int iter = 0; iter < events_size; ++iter) {
            point_cover_count += events[iter][1];
            max_point_cover_count = std::max(max_point_cover_count, point_cover_count);
        }

        if (max_point_cover_count >= point_min_count) {
            covers = true;
        } else {
            covers = false;
        }

        if (covers) {
            rad_H = mid;
        } else {
            rad_L = mid;
        }

        events.clear();
        point_cover_count = 0;
        max_point_cover_count = 0;
    }

    std::cout << std::fixed << std::setprecision(6) << rad_H << "\n";
}

int main() {
    std::ios_base::sync_with_stdio(false);
    std::cin.tie(nullptr);

    int point_array_size;
    int point_min_count;

    std::cin >> point_array_size;
    std::cin >> point_min_count;

    std::vector<std::vector<int>> points_input(point_array_size, std::vector<int>(2));

    for (int iter = 0; iter < point_array_size; ++iter) {
        std::cin >> points_input[iter][0];
        std::cin >> points_input[iter][1];
    }

    CalculateCircumference(point_min_count, points_input, point_array_size);
}