Language: C++

//
#define NDEBUG
#define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <array>
#include <cassert>
#include <climits>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <functional>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <type_traits>
#include <utility>
#include <vector>
constexpr double PI = 3.1415926535897932;

using int32 = std::int_fast64_t;
using int64 = std::int_fast64_t;
using uint32 = std::uint_fast64_t;
using uint64 = std::uint_fast64_t;
using intl32 = std::int_least32_t;
using intl64 = std::int_least64_t;
using uintl32 = std::uint_least32_t;
using uintl64 = std::uint_least64_t;

const char *yes(bool c) { return c ? "yes" : "no"; }
const char *Yes(bool c) { return c ? "Yes" : "No"; }
const char *YES(bool c) { return c ? "YES" : "NO"; }
const char *pos(bool c) { return c ? "possible" : "impossible"; }
const char *Pos(bool c) { return c ? "Possible" : "Impossible"; }
const char *POS(bool c) { return c ? "POSSIBLE" : "IMPOSSIBLE"; }
template<class T>bool bmaxi(T&a, const T&b) { if (b<a)return 0;a = b;return 1; }
template<class T>bool bmini(T&a, const T&b) { if (a<b)return 0;a = b;return 1; }
template<class T>bool nmaxi(T&a, const T&b) { if (a<b) { a = b;return 1; }return 0; }
template<class T>bool nmini(T&a, const T&b) { if (b<a) { a = b;return 1; }return 0; }
template<typename T>auto scan(T&d)->typename std::enable_if<std::is_signed<T>::value>::type
{
	d = 0;int c = fgetc(stdin);bool f = 0;while (c<'0' || '9'<c) { if (c == '-')f = 1;c = fgetc(stdin); }
	while (c != ' '&&c != '\n') { d = d * 10 + c - '0';c = fgetc(stdin); }if (f)d = -d;
}
template<typename T>auto scan(T&d)->typename std::enable_if<!std::is_signed<T>::value>::type
{
	d = 0;int c = fgetc(stdin);while (c == ' ' || c == '\n')c = fgetc(stdin);
	while (c != ' '&&c != '\n') { d = d * 10 + c - '0';c = fgetc(stdin); }
}
void scan(char&d) { d = fgetc(stdin);while (d == ' ' || d == '\n')d = fgetc(stdin); }
void scan(double&d) { scanf("%lf", &d); }void scan(std::string&d) {
	d.clear();int c = fgetc(stdin);
	while (c == ' ' || c == '\n')c = fgetc(stdin);while (c != ' '&&c != '\n') { d.push_back(c);c = fgetc(stdin); }
}
template<typename F, typename...R>void scan(F&f, R&...r) { scan(f);scan(r...); }
template<typename T>T in() { T d;scan(d);return d; }
template <typename T>auto print(T d)->typename std::enable_if<std::is_signed<T>::value>::type
{
	static int c[20];int i = 0;bool f = 0;if (d<0) { f = 1;d = -d; }while (d) { c[i++] = d % 10;d /= 10; }
	if (!i)c[i++] = 0;if (f)fputc('-', stdout);while (i--)fputc(c[i] + '0', stdout);
}
template<typename T>auto print(T d)->typename std::enable_if<!std::is_signed<T>::value>::type
{
	static int c[20];int i = 0;while (d) { c[i++] = d % 10;d /= 10; }
	if (!i)c[i++] = 0;while (i--)fputc(c[i] + '0', stdout);
}
template<>void print<char>(char d) { fputc(d, stdout); }
template<>void print<double>(double d) { printf("%f", d); }
template<>void print<char *>(char *c) { while (*c != '\0')fputc(*(c++), stdout); }void print() {}
template<typename F, typename...R>void print(F f, R...r) { print(f);print(r...); }
template<typename...R>void println(R...r) { print(r...);fputc('\n', stdout); }
template<typename...R>int END(R...r) { println(r...);return 0; }

struct angle {
	double r;
	angle() :r(0) {}
	angle(double r_) :r(arr(std::fmod(r_, 2.0 * PI) + 2.0 * PI)) {}
	static double arr(const double &o) { return o < 2.0 * PI - eps ? o : o - 2.0 * PI; }
	static angle make(const double &o) { angle ret;ret.r = o;return ret; }
	const angle operator+(const angle &o)const { return make(arr(r + o.r)); }
	const angle operator-(const angle &o)const { return make(arr(r - o.r + 2.0 * PI)); }
	const angle operator*(const double &o)const { return angle(r * o); }
	const angle operator/(const double &o)const { return angle(r / o); }
	angle &operator+=(const angle &o) { return *this = *this + o; }
	angle &operator-=(const angle &o) { return *this = *this - o; }
	angle &operator*=(const double &o) { return *this = *this * o; }
	angle &operator/=(const double &o) { return *this = *this / o; }
	const angle operator~()const { return make(arr(3.0 * PI - r)); }
	const angle operator-()const { return make(arr(2.0 * PI - r)); }
	const bool operator==(const angle &o)const { return std::abs(r - o.r) <= eps; }
	const bool operator!=(const angle &o)const { return std::abs(r - o.r) > eps; }
	const bool operator< (const angle &o)const { return r <  o.r; }
	const bool operator<=(const angle &o)const { return r <= o.r; }
	const bool operator> (const angle &o)const { return r >  o.r; }
	const bool operator>=(const angle &o)const { return r >= o.r; }
	explicit operator bool()const { return r > eps; }
	explicit operator double()const { return r; }
	const double sin()const { return std::sin(r); }
	const double cos()const { return std::cos(r); }

	const double degree()const { return r*(180.0 / PI); }
	const double ratio()const { return r / (2.0 * PI); }
private:
	static constexpr double eps = 0.0000001;
};
angle operator"" _deg(long double x) { return angle(x*(PI / 180.0)); }
angle operator"" _rat(long double x) { return angle(x * 2.0 * PI); }
angle operator"" _rad(long double x) { return angle(x); }
struct pvec {
	static constexpr double eps = 0.0000000000001;
	double x, y;
	pvec() :x(0), y(0) {}
	pvec(double x_, double y_) :x(x_), y(y_) {}
	pvec(double abs_, angle r) :x(abs_*r.cos()), y(abs_*r.sin()) {}
	const pvec operator+(const pvec &o)const { return pvec(x + o.x, y + o.y); }
	const pvec operator-(const pvec &o)const { return pvec(x - o.x, y - o.y); }
	const pvec operator*(const pvec &o)const { return pvec(x*o.x - y*o.y, x*o.y + y*o.x); }
	const pvec operator/(const pvec &o)const { return pvec(x*o.x + y*o.y, y*o.x - x*o.y) / o.abs2(); }
	const pvec operator*(const double &o)const { return pvec(x * o, y * o); }
	const pvec operator/(const double &o)const { return pvec(x / o, y / o); }
	pvec &operator+=(const pvec &o) { return *this = *this + o; }
	pvec &operator-=(const pvec &o) { return *this = *this - o; }
	pvec &operator*=(const pvec &o) { return *this = *this * o; }
	pvec &operator/=(const pvec &o) { return *this = *this / o; }
	pvec &operator*=(const double &o) { return *this = *this * o; }
	pvec &operator/=(const double &o) { return *this = *this / o; }

	const pvec operator+()const { return *this; }
	const pvec operator-()const { return pvec(-x, -y); }
	const pvec operator~()const { return pvec(x, -y); }

	explicit operator bool()const { return std::abs(x) > eps || std::abs(y) > eps; }
	const bool operator==(const pvec &o)const { return std::abs(x - o.x) <= eps&&std::abs(y - o.y) <= eps; }
	const bool operator!=(const pvec &o)const { return std::abs(x - o.x) > eps || std::abs(y - o.y) > eps; }

	const double abs()const { return mysqrt(abs2()); }
	const double abs2()const { return x*x + y*y; }
	const angle arg()const { return angle(std::atan2(y, x)); }
	static const double dot(const pvec &l, const pvec &r) { return l.x*r.x + l.y*r.y; }
	static const double cross(const pvec &l, const pvec &r) { return l.x*r.y - l.y*r.x; }
	const pvec dir()const { return *this / abs(); }

	static const bool C_x(const pvec &l, const pvec &r) {
		if (l.x != r.x) return l.x < r.x;
		return l.y < r.y;
	}
	friend std::istream &operator>>(std::istream &is, pvec &o) {
		double x_, y_;is >> x_ >> y_;o = pvec(x_, y_);return (is);
	}
private:
	static const double mysqrt(const double &x) {
		double h = 0.5*x;
		std::uint_fast64_t t = 0x5FE6EB50C7B537AAl
			- (*(std::uint_fast64_t*)&x >> 1);
		double r = *(double*)&t;
		r *= 1.5 - h*r*r;
		r *= 1.5 - h*r*r;
		r *= 1.5 - h*r*r;
		return r*x;
	}
};
void scan(pvec &d) { scan(d.x, d.y); }
int main(void) {
	const uint32 n = in<uint32>(), m = in<uint32>();
	const uint32 siz = (uint32)1 << n;
	std::vector<pvec> d(n);
	for (auto &x : d)scan(x);
	std::vector<double> t(siz, -0.00001);
	for (uint32 i = 1;i < siz;++i) {
		double mix = 200000, max = 0, miy = 200000, may = 0;
		for (uint32 k = 0;k < n;++k) {
			if (i >> k & 1) {
				bmini(mix, d[k].x);bmaxi(max, d[k].x);
				bmini(miy, d[k].y);bmaxi(may, d[k].y);
			}
		}
		pvec cent((max + mix) / 2, (may + miy) / 2);
		double dist = std::max((max - mix) / 2, (may - miy) / 2);
		for (uint32 k = 0;k < n;++k) {
			if (i >> k & 1) {
				if ((d[k] - cent).abs() > dist) {
					pvec temp = (d[k] - cent)*dist / ((d[k] - cent).abs());
					temp = cent - temp;
					cent = (temp + d[k]) / 2;
					dist = (d[k] - cent).abs();
				}
			}
		}
		t[i] = dist;
	}
	double low = 0, high = 100000;

	std::vector<uint32> dp(siz);
	for (uint32 bs = 0;bs < 100;++bs) {
		const double mid = (low + high) / 2;
		for (auto &x : dp)x = 100;
		for (uint32 i = 1;i < siz;++i) {
			if (t[i] <= mid) { dp[i] = 1;continue; }
			for (int32 k = (int32)i;k >= 0;k--) {
				k &= (int32)i;
				bmini(dp[i], dp[k] + dp[i - k]);
			}
		}
		if (dp.back() <= m)high = mid;
		else low=mid;
	}
	double ans = high;
	println(ans);
	return 0;
}


Compiler output:
a.cc: In function 'std::istream& operator>>(std::istream&, pvec&)':
a.cc:153:34: error: no match for 'operator>>' (operand types are 'std::istream' {aka 'std::basic_istream<char>'} and 'double')
  153 |                 double x_, y_;is >> x_ >> y_;o = pvec(x_, y_);return (is);
      |                               ~~ ^~ ~~
      |                               |     |
      |                               |     double
      |                               std::istream {aka std::basic_istream<char>}
In file included from /usr/include/c++/14/bits/memory_resource.h:38,
                 from /usr/include/c++/14/unordered_map:59,
                 from /usr/include/c++/14/functional:63,
                 from a.cc:13:
/usr/include/c++/14/cstddef:131:5: note: candidate: 'template<class _IntegerType> constexpr std::__byte_op_t<_IntegerType> std::operator>>(byte, _IntegerType)'
  131 |     operator>>(byte __b, _IntegerType __shift) noexcept
      |     ^~~~~~~~
/usr/include/c++/14/cstddef:131:5: note:   template argument deduction/substitution failed:
a.cc:153:31: note:   cannot convert 'is' (type 'std::istream' {aka 'std::basic_istream<char>'}) to type 'std::byte'
  153 |                 double x_, y_;is >> x_ >> y_;o = pvec(x_, y_);return (is);
      |                               ^~
In file included from /usr/include/c++/14/string:55,
                 from a.cc:20:
/usr/include/c++/14/bits/basic_string.tcc:835:5: note: candidate: 'template<class _CharT, class _Traits, class _Alloc> std::basic_istream<_CharT, _Traits>& std::operator>>(basic_istream<_CharT, _Traits>&, __cxx11::basic_string<_CharT, _Traits, _Allocator>&)'
  835 |     operator>>(basic_istream<_CharT, _Traits>& __in,
      |     ^~~~~~~~
/usr/include/c++/14/bits/basic_string.tcc:835:5: note:   template argument deduction/substitution failed:
a.cc:153:37: note:   mismatched types 'std::__cxx11::basic_string<_CharT, _Traits, _Allocator>' and 'double'
  153 |                 double x_, y_;is >> x_ >> y_;o = pvec(x_, y_);return (is);
      |                                     ^~