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

using ll = long long;
#define rep(i, n) for(ll i = 0; i < n; i++)
#define rep2(i, l, r) for(ll i = l; i < r; i++)

using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;

/* ---- */
#define all(A) A.begin(), A.end()
#define elif else if
using pii = pair<ll, ll>;

bool chmin(auto &a, const auto &b) {return a > b ? a = b, 1 : 0;}
bool chmax(auto &a, const auto &b) {return a < b ? a = b, 1 : 0;}

struct IOSetup {
  IOSetup() {
    cin.tie(0);
    ios::sync_with_stdio(0);
  }
} iosetup;

template<class T>
void print(vector<T> a) {
  for (auto x : a) cerr << x << ' ';
  cerr << endl;
}

void print(auto x) {
  cerr << x << endl;
}

template<class Head, class... Tail>
void print(Head&& head, Tail&&... tail) {
  cerr << head << ' ';
  print(forward<Tail>(tail)...);
}

double stop_watch(struct timespec start_time) {
    // 経過時間を秒単位で返す.
    struct timespec end_time;
    clock_gettime(CLOCK_REALTIME, &end_time);
    long long int sec = end_time.tv_sec - start_time.tv_sec;
    long long int nsec = end_time.tv_nsec - start_time.tv_nsec;
    return (double)sec + (double)nsec / (1000 * 1000 * 1000);
}


// https://noshi91.hatenablog.com/entry/2023/02/18/005856
// https://nyaannyaan.github.io/library/dp/monge-d-edge-shortest-path-enumerate.hpp

template <typename T>
vector<T> monge_shortest_path(int N, const function<T(int, int)>& f) {
  T INF = 1e100;
  vector<T> dp(N + 1, INF);
  vector<int> x(N + 1, 0);
  auto check = [&](int from, int to) {
    if (from >= to) return;
    T cost = f(from, to);
    if (dp[from] + cost < dp[to]) dp[to] = dp[from] + cost, x[to] = from;
  };
  auto dfs = [&](auto rc, int l, int r) -> void {
    if (l + 1 >= r) return;
    int m = (l + r) / 2;
    for (int i = x[l]; i <= x[r]; i++) check(i, m);
    rc(rc, l, m);
    for (int i = l + 1; i <= m; i++) check(i, r);
    rc(rc, m, r);
  };
  dp[0] = 0, check(0, N), dfs(dfs, 0, N);
  return dp;
}

using ld=long double;
ld inf=1e100;
ld phi=1.618033988749895;
int main(){
  struct timespec start_time;
  clock_gettime(CLOCK_REALTIME, &start_time);

  int n,m;
  cin>>n>>m;
  vector<ld>a(n);
  rep(i,n)cin>>a[i];
  sort(a.begin(),a.end());
  vector<ld>cum(n+1,0);
  rep(i,n)cum[i+1]=cum[i]+a[i];

  auto calc=[&](ld x)->ld{
    auto cost=[&](int l,int r)->ld{
      return sqrtl((r-l)*(cum[r]-cum[l]))+x;
    };
    return monge_shortest_path<ld>(n,cost)[n]-m*x;
  };

  pair<ld,ld>l,ml,mr,r;
  l={0,-inf};
  r={3*sqrtl(n*cum[n]+10),-inf};
  {
    ld x=(phi-1)*l.first+(2-phi)*r.first;
    ml={x,calc(x)};
  }
  {
    ld x=(phi-1)*ml.first+(2-phi)*r.first;
    mr={x,calc(x)};
  }

  print(l.first,ml.first,mr.first,r.first);

  rep(i,120){
    // print(l.first,ml.first,mr.first,r.first);
    if(ml.second>mr.second){
      r=mr;
      mr=ml;
      ld x=(phi-1)*l.first+(2-phi)*mr.first;
      ml={x,calc(x)};
    }
    else{
      l=ml;
      ml=mr;
      ld x=(phi-1)*ml.first+(2-phi)*r.first;
      mr={x,calc(x)};
    }
  }
  cout<<fixed<<setprecision(20)<<calc(ml.first)<<endl;
}