#include <bits/extc++.h>
using namespace std;

#define C const
#define SC static
#define CE constexpr
#define TL template
#define TN typename
#define OP operator
#define pb push_back
#define ft first
#define sd second
#define TTT TL<TN T = I>
#define BE(v) v.begin(), v.end()
#define VD void
#define I int
#define LL long long
#define STR string
using PII = pair<I, I>;
TTT using V = vector<T>;

#define FORX(v) for(auto& x : v)
#define FOR(i, b, e)  for(I i = b, _e = e;i < _e; ++i)
#define FORR(i, b, e) for(I i = b, _e = e;i > _e; --i)
#define FUNC(T, f, ...) function<T(__VA_ARGS__)> f = [&](__VA_ARGS__)->T

TTT CE T inf() { return numeric_limits<T>::max() / 2; }
TTT VD setmin(T& a, C T& b) { if (b < a)a = b; }
TTT VD setmax(T& a, C T& b) { if (a < b)a = b; }

#define mi (l+(r-l)/2)
struct DQIM//DynamicQuadrilateralInequalityMinimum
{
	I n, m = 0, t = 0;
	V<PII> a{ {0,-1} };
	function<bool(I, I, I)> cmp;//cmp(i,j,k) : returns true if for i, j is better than k
	TTT DQIM(I n, T&& cmp) :n(n), cmp(cmp) {}
	I query(I i) { return upper_bound(BE(a), PII(i, m))->sd; }
	VD add()
	{
		while (t && cmp(a[t - 1].ft, m, a[t].sd))a.pop_back(), --t;
		if (t && cmp(a[t].ft - 1, m, a[t].sd))
		{
			I l = a[t - 1].ft, r = n;
			while (l + 1 < r)(!cmp(mi, m, a[t].sd) ? l : r) = mi;
			a[t].ft = r; a.pb({ n,m }), ++t;
		}
		else if (a[t].ft < n)a.pb({ n,m }), ++t;
		++m;
	}
};

//CountLimitationBinarySearch
//f should be a function which receives a shift value and returns a pair {min_value, count}
//mxc: =1 means the count returned by f is maximized, =0 means minimized, useful only when S is integer type
//WARNING: [l,r) is the range of shift value, not the answer
TL<TN S, TN T, I mxc = 1> S clbs(C function<pair<S, T>(S)>& f, T c, S l, S r, S eps = 1)
{
	while (l + eps < r)(f(mi).sd >= c ? l : r) = mi;
	return f(mxc ? l : r).ft - (mxc ? l : r) * c;
}

using D = double;
VD test()
{
	I n, m; cin >> n >> m;
	V<LL> a(n + 1);
	FOR(i, 1, n + 1)cin >> a[i];
	sort(BE(a)); FOR(i, 1, n + 1)a[i] += a[i - 1];
	using PDI = pair<D, I>;
	FUNC(PDI, dp, D sv)
	{
		V<D> f(n + 1); V<I> c(n + 1);
		FUNC(D, calc, I i, I j) { return sqrt((i - j) * (a[i] - a[j])); };
		FUNC(bool, cmp, I i, I j, I k) { return  f[j] + calc(i, j) < f[k] + calc(i, k); };
		DQIM dq(n + 1, cmp); dq.add();
		FOR(i, 1, n + 1)
		{
			I j = dq.query(i);
			f[i] = f[j] + calc(i, j) + sv;
			c[i] = c[j] + 1;
			dq.add();
		}
		return { f[n],c[n] };
	};
	cout << fixed << setprecision(10) << clbs<D, I>(dp, m, -1e10, 1e10, 1e-12);
}

I main()
{
	ios::sync_with_stdio(0);
	cin.tie(0), cout.tie(0);
	if (fopen("test.in", "r"))
	{
		freopen("test.in", "r", stdin);
		freopen("test.out", "w", stdout);
	}
	I t = 1;
	// cin >> t;
	while (t--)test();
	return 0;
}