Problem:
D: 水槽
問題
AORイカちゃんは縦 $1$ 横 $N$ の大きさの水槽をもらった。水槽は水を入れるのに十分な高さがある。
水槽には $N-1$ 個の仕切りがあり $N$ 個の区画に等間隔に区切られている。
ここに水を注いだところ、各区画の水の高さは $a_i$ になった。
AORイカちゃんはいくつか仕切りを取り除き、区画の数を $M$ 個以下にすることにした。
仕切りを取り除き終わった時、各区画の水の高さの総和の最大値を求めよ。
なお、仕切りの厚さは無視できるものとする。
制約
$1 \le N \le 500$
$1 \le M \le N$
$1 \le a_i \le 10^9$
入力は全て整数
入力
$N \ M$
$a_1 \cdots a_N$
出力
各区画の水の高さの総和の最大値を一行で出力せよ。また末尾に改行を出力せよ。
相対誤差または絶対誤差が $10^{-6}$ 以下であれば許容される。
サンプル
サンプル入力 1
5 3
9 1 2 3 9
サンプル出力 1
20.000000
$a_2$ と $a_3$ 、$a_3$ と $a_4$ の間の仕切りをとると、その区画の水の高さは $\frac{(1 + 2 + 3)}{3} = 2$ となる。
 各区画の水の高さは $9 \ 2 \ 9$ となりこれが最大である。
サンプル入力 2
4 1
14 4 9 7
サンプル出力 2
8.500000
サンプル入力 3
8 3
11 18 9 20 4 18 12 14
サンプル出力 3
44.666667

Submitted solutions:

code_snippet: #include <bits/stdc++.h>
//#include <atcoder/all>
#include <iomanip>
using namespace std;
//using namespace atcoder;
using ll = long long;
using pint = pair<int, int>;
//using mint = modint998244353;
template<typename T>
using min_priority_queue = priority_queue<T, vector<T>, greater<T>>;
#define rep(i,n) for(int i = 0; i < (n); ++i)
template<typename T>
bool chmax(T& a, const T& b) { if (a < b) { a = b; return true; } return false; }
template<typename T>
bool chmin(T& a, const T& b) { if (a > b) { a = b; return true; } return false; }
int main() {
    int n, m; cin >> n >> m;
    vector<ll> sum(n + 1);
    rep(i, n)cin >> sum[i + 1], sum[i + 1] += sum[i];
    const double inf = -1e18;
    vector dp(n + 1, vector<double>(m + 1, inf));
    dp[0][0] = 0;
    for (int i = 1; i <= n; ++i)for (int j = 1; j <= m; ++j)rep(k, i) {
        chmax(dp[i][j], dp[k][j - 1] + (double)(sum[i] - sum[k]) / (i - k));
    }
    printf("%.10lf\n", dp[n][m]);
}
accuracy: 1
time_ms: 80
memory_kb: 5760
final_rank: 13

code_snippet: #include <bits/stdc++.h>
#define ll long long
#define ld long double
using namespace std;


int main(void){
    int n,m;
    cin >> n >> m;
    vector<ll> a(n),s(n+1,0);
    for(int i = 0;i < n;i++){
        cin >> a[i];
        s[i+1] = a[i];
        s[i+1] += s[i];
    }
    
    vector<vector<ld>> dp(m,vector<ld>(n,0));
    for(int i = 0;i < n;i++){
        dp[0][i] = (ld)s[i+1]/(i+1);
    }
    for(int i = 1;i < m;i++){
        for(int j = 0;j < n;j++){
            ld ma = dp[i-1][j];
            int d = 0;
            for(int k = 0;k < j;k++){
                if(dp[i-1][k]+(ld)(s[j+1]-s[k+1])/(j-k) > ma){
                    d = k;
                }
                ma = max(ma,dp[i-1][k]+(ld)(s[j+1]-s[k+1])/(j-k));
            }
            dp[i][j] = ma;
            //cout << d << " ";
        }
        //cout << endl;
    }
    /*
    cout << endl;
    for(auto& i:s) cout << i << " ";
    cout << endl << endl;
    
    for(auto& i:dp){
        for(auto& j:i) cout << j << " ";
        cout << endl;
    }
    //*/
    
    ld ans = 0;
    for(int i = 0;i < m;i++){
        ans = max(ans,dp[i][n-1]);
    }
    
    cout << fixed << setprecision(8) << ans << endl;
}
accuracy: 1
time_ms: 150
memory_kb: 7072
final_rank: 17

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

template <typename T>
using vc = vector<T>;
template <typename T>
using vv = vc<vc<T>>;

//-------------1.型系---------------
using ll = long long;
ll INF = 2e18;

using ld = long double;
using bl = bool;

template <class T>
using pq = priority_queue<T, vc<T>>;
template <class T>
using pq_g = priority_queue<T, vc<T>, greater<T>>;
//-----------------------------------

//-------------2.配列系--------------
using pii = pair<int, int>;
using pll = pair<long long, long long>;

#define rep(i, n) for (ll i = 0; i < (n); ++i)
template <class T>
istream &operator>>(istream &i, vc<T> &v)
{
    rep(j, size(v)) i >> v[j];
    return i;
}

using ar2 = array<ll, 2>;

//----------------------------------

//--------3.コード短縮化とか---------
const double PI = 3.141592653589793238;
const int inf = 1073741823;
const ll infl = 1LL << 60;
const string ABC = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
const string abc = "abcdefghijklmnopqrstuvwxyz";

#define rep(i, n) for (ll i = 0; i < (n); ++i)
#define drep(i, n) for (ll i = (n) - 1; i >= 0; --i)
#define nfor(i, s, n) for (ll i = s; i < n; i++)
#define dfor(i, s, n) for (ll i = (s) - 1; i >= n; i--)

#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()

#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)

#define Yes cout << "Yes" << endl
#define No cout << "No" << endl
#define YN                     \
    {                          \
        cout << "Yes" << endl; \
    }                          \
    else                       \
    {                          \
        cout << "No" << endl;  \
    } // if(a==b)YN;

#define vc_unique(v) v.erase(unique(v.begin(), v.end()), v.end());
#define vc_rotate(v) rotate(v.begin(), v.begin() + 1, v.end());

#define pop_cnt(s) ll(popcount(uint64_t(s)))

#define next_p(v) next_permutation(v.begin(), v.end())

//-------------------------------

//---------4.グリッド系----------
vector<int> dx = {1, 0, -1, 0}; // vl dx={1,1,0,-1,-1,-1,0,1};
vector<int> dy = {0, 1, 0, -1}; // vl dy={0,1,1,1,0,-1,-1,-1};

bool out_grid(ll i, ll j, ll h, ll w = -1)
{
    if (w == -1)
    {
        w = h;
    }
    return (!(0 <= i && i < h && 0 <= j && j < w));
}

//----------------------------------------------

//-----------6.デバックや出力系------------------
void print(ld x) { printf("%.20Lf\n", x); }

#define print_vec(v)                   \
    {                                  \
        ll n = size(v);                \
        rep(i, n) cout << v[i] << " "; \
        cout << endl;                  \
    } // 一次元配列を出力する(改行なし)

#define vc_cout(v)                      \
    {                                   \
        ll n = size(v);                 \
        rep(i, n) cout << v[i] << endl; \
    } // 一次元配列を出力する(改行あり)
#define vv_cout(v)                                         \
    {                                                      \
        ll n = size(v);                                    \
        rep(i, n)                                          \
        {                                                  \
            rep(j, size(v[i])) { cout << v[i][j] << ' '; } \
            cout << endl;                                  \
        }                                                  \
    } // 二次元配列を出力する

//----------------------------------------------

int main()
{
    cout << fixed << setprecision(10) << endl;
    int n, m;
    cin >> n >> m;
    vector<double> h(n), sum(n + 1);
    cin >> h;
    rep(i, n) sum[i + 1] = sum[i] + h[i];
    vector dp(m + 1, vector<double>(n + 1, -inf));
    dp[0][0] = 0;
    rep(i, m)
    {
        nfor(j, 1, n + 1)
        {
            rep(k, j)
            {
                double val = (sum[j] - sum[k]) / (j - k);
                chmax(dp[i + 1][j], dp[i][k] + val);
            }
        }
    }
    cout << dp[m][n] << endl;
    return 0;
}
accuracy: 1
time_ms: 50
memory_kb: 5252
final_rank: 5

code_snippet: #include <bits/stdc++.h>

/*
*/

using namespace std;
//make -f ../makefile SRC=


/*
TODO

*/

//------------------------------------------------------------------------------
bool DEBUG = false;
const double INF = 1e18;

const int MAX_N = 500;
static int vect[MAX_N];
static double P[MAX_N]; // prefix sum

const int MAX_K = 500;
static double S[MAX_N][MAX_K]; // k, ends in

//------------------------------------------------------------------------------
void test()
{
}

//------------------------------------------------------------------------------
// top down dp
double dp(int N, int K, int i, int k)
{
    if (i < 0 || k < 0) return 0;
    if (S[i][k] != -1) return S[i][k];

    double& res = S[i][k];
    if (i < k) { res = 0; return res; }
    else if (i == k) { res = P[i]; return res; }
    else if (k == 0) { res = P[i]/(i+1); return res; }

    res = 0;
    for (int i1=i-1; i1>=k-1 && i1<i; --i1)
    {
        double v = P[i];
        if (i1 >= 0) v -= P[i1]; //<----------
        v /= (i-i1);
        res = max(res, v + dp(N, K, i1, k-1));
    }

    return res;
}

//------------------------------------------------------------------------------
double solve(int N, int K)
{
    if (DEBUG) printf("N=%d, K=%d\n", N, K);
    if (DEBUG) {printf("vect: "); for (int i=0; i<N; ++i) printf("%d ",vect[i]); printf("\n");}
    //--------------------------------------------------------------------------
    // base cases:
    //--------------------------------------------------------------------------
    // init:
    P[0] = vect[0];
    for (int i=1; i<N; ++i) P[i] = vect[i] + P[i-1];
    if (DEBUG) {printf("P: "); for (int i=0; i<N; ++i) printf("%lf ",P[i]); printf("\n");}

    for (int i=0; i<N; ++i) for (int k=0; k<K; ++k) S[i][k] = -1;
    //--------------------------------------------------------------------------
    double res = dp(N, K, N-1, K-1);
    if (DEBUG)
    {
        for (int i=0; i<N; ++i)
            for (int k=0; k<K; ++k)
                if (S[i][k] != -1)
                    printf("i=%d, k=%d, S=%lf\n", i, k, S[i][k]);
    }
    return res;
}

//------------------------------------------------------------------------------
int main()
{
    //DEBUG = true;
    //test(); return 0;
    //--------------------------------------------------------------------------
    int N, K, num;
    num = scanf("%d %d ", &N, &K);
    for (int i=0; i<N; ++i) num = scanf("%d ", &vect[i]);
    double res = solve(N, K);
    printf("%0.6lf\n", res);
    //--------------------------------------------------------------------------
    return 0;
}
//------------------------------------------------------------------------------
accuracy: 1
time_ms: 20
memory_kb: 5548
final_rank: 1

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

#define rep(i, l, r) for (int i = (int)(l); i<(int)(r); i++)
#define ll long long
#define all(x) (x).begin(), (x).end() 

template<class T> bool chmin(T& a, T b) {if (a > b) {a = b; return 1;} return 0;}
template<class T> bool chmax(T& a, T b) {if (a < b) {a = b; return 1;} return 0;}

const int inf = 1e9;
const ll INF = 4e18;

int main() {
    int N, M; cin >> N >> M;
    vector<long double> S(N+1, 0);
    rep(i, 1, N+1) cin >> S[i];
    rep(i, 1, N+1) S[i] += S[i-1];
    //dp[i][j][k] = i番目の水槽までみたときの終了区画の数がjで、最後に取り除いたのが区画kの右のときのmax
    vector<vector<vector<long double> > > dp(2, vector<vector<long double> >(N+1, vector<long double>(N+1, -INF)));
    dp[0][0][0] = 0;
    rep(i, 0, N) rep(j, 0, i+1) rep(k, 0, i+1) {
        if (dp[i%2][j][k] == -INF) continue;
        //次で切る
        chmax(dp[(i+1)%2][j+1][i+1], dp[i%2][j][k] + (S[i+1]-S[k])/(i+1-k));
        //切らない
        chmax(dp[(i+1)%2][j][k], dp[i%2][j][k]);
    } 
    long double ans = -INF;
    rep(i, 0, M+1) chmax(ans, dp[N%2][i][N]);
    cout << fixed << setprecision(15) << ans << endl;
}
accuracy: 1
time_ms: 190
memory_kb: 14888
final_rank: 20

code_snippet: #pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef unsigned long long int ull;

mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
ll myRand(ll B) { return (ull)rng() % B; }

int main() {
    cin.tie(nullptr);
    ios::sync_with_stdio(false);
    int n, m;
    cin >> n >> m;
    vector<double> a(n), s(n + 1);
    for (int i = 0; i < n; ++i) {
        cin >> a[i];
        s[i + 1] = s[i] + a[i];
    }
    vector<vector<double>> dp(n + 1, vector<double>(m + 1, -1));
    dp[0][0] = 0;
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < m; ++j) {
            if (dp[i][j] == -1) continue;
            for (int k = i; k < n; ++k) {
                dp[k + 1][j + 1] =
                    max(dp[k + 1][j + 1], dp[i][j] + (s[k + 1] - s[i]) / (k - i + 1));
            }
        }
    }
    printf("%.9f\n", dp[n][m]);
}
accuracy: 1
time_ms: 20
memory_kb: 5592
final_rank: 2

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

/* BOOST MULTIPRECISION
#include<boost/multiprecision/cpp_int.hpp>
using namespace boost::multiprecision;
//*/

typedef long long ll;

#define rep(i, s, n) for (int i = (int)(s); i < (int)(n); i++)
#define rrep(i, s, n) for (int i = (int)(n)-1; i >= (int)(s); i--)

template <typename T> bool chmin(T &a, const T &b) {
	if (a <= b) return false;
	a = b;
	return true;
}

template <typename T> bool chmax(T &a, const T &b) {
	if (a >= b) return false;
	a = b;
	return true;
}

template <typename T> T max(vector<T> &a){
	assert(!a.empty());
	T ret = a[0];
	for (int i=0; i<(int)a.size(); i++) chmax(ret, a[i]);
	return ret;
}

template <typename T> T min(vector<T> &a){
	assert(!a.empty());
	T ret = a[0];
	for (int i=0; i<(int)a.size(); i++) chmin(ret, a[i]);
	return ret;
}

template <typename T> T sum(vector<T> &a){
	T ret = 0;
	for (int i=0; i<(int)a.size(); i++) ret += a[i];
	return ret;
}

int main(){
	ios_base::sync_with_stdio(false);
	cin.tie(NULL);
	int n, m; cin >> n >> m;
	vector<double> a(n);
	rep(i,0,n) cin >> a[i];
	vector dp(n+1, vector<double>(m+1, -1e18));
	dp[0][0] = 0;

	vector<double> rui(n+1);
	rep(i,0,n) rui[i+1] = rui[i] + a[i];


	rep(i,1,n+1){
		rep(j,0,m){
			rep(k,0,i){
				chmax(dp[i][j+1], dp[k][j] + (rui[i] - rui[k]) / double(i - k));
			}
		}
	}

	double ans = 0;
	rep(i,0,m+1){
		chmax(ans, dp[n][i]);
	}

	cout << fixed << setprecision(15);
	cout << ans << '\n';
}
accuracy: 1
time_ms: 90
memory_kb: 5256
final_rank: 12

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

#define int long long
#define ll long long

#define rep(i, n) for (ll i = 0; i < n; ++i)
#define all(v) begin(v), end(v)
// #define BIT(n) (1LL << (n))
#define MAX(type) numeric_limits<type>::max()
#define MIN(type) numeric_limits<type>::min()
#define yes cout << "Yes" << endl
#define no cout << "No" << endl
#define pb push_back
#define mp make_pair
#define fir first
#define sec second

signed main() {
  int N, M;
  cin >> N >> M;
  vector<int> A(N);
  rep(i, N) {
    cin >> A[i];
  }
  // dp[i][j] := i個目まで見て、j個消しているときの水の高さの総和の最大値
  vector<vector<double>> dp(N, vector<double>(N, 0));
  vector<double> a_sum(N+1, 0);
  rep(i, N) {
    a_sum[i+1] = a_sum[i] + A[i];
  }
  rep(i, N) dp[i][0] = a_sum[i+1];
  rep(i, N) {
    rep(j, i+1) {
      if(i!=0 && j < i) dp[i][j] = dp[i-1][j] + A[i];
      else if(j < i) dp[i][j] = A[i];
      if(i == j) {
        dp[i][j] = max(dp[i][j], a_sum[i+1] / (i+1));
      } else {
        rep(k, i) {
          // 前に生きてるのがk

          // dp[i][j] = max(dp[i][j], dp[k][k] + (dp[i-k][0] - dp[k][0]) / (i-k) );
          // cout << i << " " << j << " " << k << " " << dp[k][k] << " " << (dp[i-k][0] - dp[k][0]) / (i-k) << endl;
          int remain = j - (i - k - 1);
          if(remain < 0) continue;
          if(remain > j) continue;
          dp[i][j] = max(dp[i][j], dp[k][remain] + (a_sum[i+1] - a_sum[k+1]) / (i-k));
        }
      }
    }
  }

  /*
  rep(i, N) {
    rep(j, N) {
      cout << dp[i][j] << " ";
    }
    cout << endl;
  }
  */

  double ans = 0;
  for(int i=N-M; i<N; i++) {
    ans = max(ans, dp[N-1][i]);
  }
  cout << setprecision(15) << fixed << ans << endl;
}
accuracy: 1
time_ms: 50
memory_kb: 5540
final_rank: 6

code_snippet: #include <bits/stdc++.h>
using namespace std;
using ll = long long;

#define FOR(i, l, r) for(ll i = l; i < r; i++)
#define rep(i, n) FOR(i, 0, n)
#define FORR(i, l, r) for(ll i = r - 1; i >= l; i--)
#define ALL(ar) begin(ar), end(ar)

template <typename T1, typename T2>
inline bool chmax(T1 &a, T2 b) {
    return a < b && (a = b, true);
}
template <typename T1, typename T2>
inline bool chmin(T1 &a, T2 b) {
    return a > b && (a = b, true);
}
template <typename T1, typename T2>
istream &operator>>(istream &is, pair<T1, T2> &p) {
    is >> p.first >> p.second;
    return is;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
    os << p.first << ' ' << p.second;
    return os;
}
template <typename T>
istream &operator>>(istream &is, vector<T> &v) {
    for(T &x : v) is >> x;
    return is;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
    for(size_t i = 0; i < v.size(); i++) os << (i ? " " : "") << v[i];
    return os;
}
//-------------------------------------------------

void solve() {
    int n, m;
    cin >> n >> m;
    vector<double> a(n);
    cin >> a;

    a.push_back(0);
    FORR(i, 0, n) a[i] += a[i + 1];

    static double dp[505][505]{};
    rep(i, 505) rep(j, 505) dp[i][j] = -1e18;
    dp[0][0] = 0;
    rep(i, n) rep(j, m) {
        FOR(nxt, i + 1, n + 1) {
            double sum = a[i] - a[nxt];
            chmax(dp[nxt][j + 1], dp[i][j] + sum / (nxt - i));
        }
    }

    double ans = 0;
    rep(i, m + 1) chmax(ans, dp[n][i]);

    cout << fixed << setprecision(10);
    cout << ans << endl;
}

int main() {
    int t = 1;
    // cin >> t;
    while(t--) solve();
}
accuracy: 1
time_ms: 50
memory_kb: 5604
final_rank: 7

code_snippet: #include <bits/stdc++.h>
#include <vector>
using namespace std;
int inf=100000000;
using ll=long long;
using pint=pair<int,int>;
using pll=pair<ll,ll>;
using pque_int=priority_queue<int>;
#define rep(i,n) for (int i=0; i < (int) n; i++)
template<typename T> inline bool chmax(T &a, T b) { return ((a < b) ? (a = b, true) : (false)); }
template<typename T> inline bool chmin(T &a, T b) { return ((a > b) ? (a = b, true) : (false)); }
long double VecMax(vector<long double> &v) {
    long double output=-inf;
    rep(i,v.size()) chmax(output,v[i]);
    return output;
}
int VecMin(vector<ll> &v) {
    ll output=inf;
    rep(i,v.size()) chmin(output,v[i]);
    return output;
}
ll VecSum(vector<ll> &v) {
    ll output=0;
    rep(i,v.size()) output+=v[i];
    return output;
}
ll pow(ll a,ll n) {
    ll output=1;
    while (n>0) output*=a;
    return output;
}
int main() {
    int N,M;
    cin >> N >> M;
    vector<long double> a(N);
    rep(i,N) cin >> a[i];

    vector<long double> sumA(N,0);
    long double s=0;
    rep(i,N) {
        s+=a[i];
        sumA[i]=s;
    }

    vector<vector<long double>> dp(N+1,vector<long double>(M+1,-1));
    dp[0][1]=a[0];
    for (int i=0; i<N; i++) {
        dp[i][1]=sumA[i]/(i+1);
        rep(j,M) {
            if (dp[i][j]==-1) continue;
            for (int k=1; k<N-i; k++) {
                dp[i+k][j+1]=max(dp[i+k][j+1],(dp[i][j]+(sumA[i+k]-sumA[i])/k));
            }
        }
    }
    cout << fixed << setprecision(10);
    cout << VecMax(dp[N-1]) << endl;
}
accuracy: 1
time_ms: 70
memory_kb: 7128
final_rank: 15

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

using ll = long long;
using ld = long double;
using vi = vector<int>;
using vl = vector<ll>;
using vvi = vector<vector<int>>;
using vvl = vector<vector<ll>>;

struct Edge {
    int from;
    int to;
    ll weight;
};

struct Graph {
    int n;
    int m;
    vector<Edge> edges;
    vector<vector<Edge>> adj;
};

// 無向辺 0-indexed
void add_edge(Graph &g, int from, int to, ll weight) {
    g.adj[from].push_back(Edge{from, to, weight});
    g.adj[to].push_back(Edge{to, from, weight});
    g.edges.push_back(Edge{from, to, weight});
}

// 有向辺 0-indexed
void add_directed_edge(Graph &g, int from, int to, ll weight) {
    g.adj[from].push_back(Edge{from, to, weight});
    g.edges.push_back(Edge{from, to, weight});
}

// 累積和 1-indexed
// cumsum[i] = v[0] + v[1] + ... + v[i - 1]
template <class T> vector<T> cumsum(vector<T> &v) {
    vector<T> ret(v.size() + 1, 0);
    for (int i = 0; i < v.size(); i++) {
        ret[i + 1] = ret[i] + v[i];
    }
    return ret;
}

#define overload4(_1, _2, _3, _4, name, ...) name
#define rep1(n) for (int i = 0; i < n; ++i)             // i: [0, n)
#define rep2(i, n) for (int i = 0; i < n; ++i)          // i: [0, n)
#define rep3(i, a, b) for (int i = a; i < b; ++i)       // i: [a, b)
#define rep4(i, a, b, c) for (int i = a; i < b; i += c) // i: [a, b) step c
#define rep(...) overload4(__VA_ARGS__, rep4, rep3, rep2, rep1)(__VA_ARGS__)
#define all(v) (v).begin(), (v).end()

const ll MOD = 998244353;
const ll MOD17 = 1000000007;
const ld PI = M_PI;
const ll INF = 1LL << 62;

const vector<char> abc = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i',
                          'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r',
                          's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};

struct Data {
    ll best;
    ll mod;
};

int main() {
    std::cin.tie(0)->sync_with_stdio(0);
    int n, m;
    cin >> n >> m;
    vector<ld> a(n);
    for (int i = 0; i < n; i++) {
        cin >> a[i];
    }

    vector<ld> cs = cumsum(a);

    vector<vector<ld>> dp(n + 1, vector<ld>(n + 1, -1e9));

    dp[0][1] = cs[n] / n;

    for (int i = 1; i < n; i++) {
        for (int j = 2; j <= n; j++) {
            ld x = 0;
            for (int k = 0; k < i; k++) {
                if (dp[k][j - 1] == -1e9) {
                    continue;
                }
                x = max(x, dp[k][j - 1] - (cs[n] - cs[k]) / (n - k) +
                               (cs[i] - cs[k]) / (i - k) +
                               (cs[n] - cs[i]) / (n - i));
            }
            dp[i][j] = x;
        }
    }

    ld ans = 0;
    for (int i = 0; i < n; i++) {
        for (int j = 1; j <= m; j++) {
            ans = max(ans, dp[i][j]);
        }
    }
    cout << fixed << setprecision(10) << ans << endl;
}
accuracy: 1
time_ms: 270
memory_kb: 7104
final_rank: 19

code_snippet: #line 2 "/Users/noya2/Desktop/Noya2_library/template/template.hpp"
using namespace std;

#include<bits/stdc++.h>
#line 1 "/Users/noya2/Desktop/Noya2_library/template/inout_old.hpp"
namespace noya2 {

template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &p){
    os << p.first << " " << p.second;
    return os;
}
template <typename T, typename U>
istream &operator>>(istream &is, pair<T, U> &p){
    is >> p.first >> p.second;
    return is;
}

template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v){
    int s = (int)v.size();
    for (int i = 0; i < s; i++) os << (i ? " " : "") << v[i];
    return os;
}
template <typename T>
istream &operator>>(istream &is, vector<T> &v){
    for (auto &x : v) is >> x;
    return is;
}

void in() {}
template <typename T, class... U>
void in(T &t, U &...u){
    cin >> t;
    in(u...);
}

void out() { cout << "\n"; }
template <typename T, class... U, char sep = ' '>
void out(const T &t, const U &...u){
    cout << t;
    if (sizeof...(u)) cout << sep;
    out(u...);
}

template<typename T>
void out(const vector<vector<T>> &vv){
    int s = (int)vv.size();
    for (int i = 0; i < s; i++) out(vv[i]);
}

struct IoSetup {
    IoSetup(){
        cin.tie(nullptr);
        ios::sync_with_stdio(false);
        cout << fixed << setprecision(15);
        cerr << fixed << setprecision(7);
    }
} iosetup_noya2;

} // namespace noya2
#line 1 "/Users/noya2/Desktop/Noya2_library/template/const.hpp"
namespace noya2{

const int iinf = 1'000'000'007;
const long long linf = 2'000'000'000'000'000'000LL;
const long long mod998 =  998244353;
const long long mod107 = 1000000007;
const long double pi = 3.14159265358979323;
const vector<int> dx = {0,1,0,-1,1,1,-1,-1};
const vector<int> dy = {1,0,-1,0,1,-1,-1,1};
const string ALP = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
const string alp = "abcdefghijklmnopqrstuvwxyz";
const string NUM = "0123456789";

void yes(){ cout << "Yes\n"; }
void no(){ cout << "No\n"; }
void YES(){ cout << "YES\n"; }
void NO(){ cout << "NO\n"; }
void yn(bool t){ t ? yes() : no(); }
void YN(bool t){ t ? YES() : NO(); }

} // namespace noya2
#line 1 "/Users/noya2/Desktop/Noya2_library/template/utils.hpp"
namespace noya2{

unsigned long long inner_binary_gcd(unsigned long long a, unsigned long long b){
    if (a == 0 || b == 0) return a + b;
    int n = __builtin_ctzll(a); a >>= n;
    int m = __builtin_ctzll(b); b >>= m;
    while (a != b) {
        int mm = __builtin_ctzll(a - b);
        bool f = a > b;
        unsigned long long c = f ? a : b;
        b = f ? b : a;
        a = (c - b) >> mm;
    }
    return a << min(n, m);
}

template<typename T> T gcd_fast(T a, T b){ return static_cast<T>(inner_binary_gcd(abs(a),abs(b))); }

long long sqrt_fast(long long n) {
    if (n <= 0) return 0;
    long long x = sqrt(n);
    while ((x + 1) * (x + 1) <= n) x++;
    while (x * x > n) x--;
    return x;
}

template<typename T> T floor_div(const T n, const T d) {
    assert(d != 0);
    return n / d - static_cast<T>((n ^ d) < 0 && n % d != 0);
}

template<typename T> T ceil_div(const T n, const T d) {
    assert(d != 0);
    return n / d + static_cast<T>((n ^ d) >= 0 && n % d != 0);
}

template<typename T> void uniq(vector<T> &v){
    sort(v.begin(),v.end());
    v.erase(unique(v.begin(),v.end()),v.end());
}

template <typename T, typename U> inline bool chmin(T &x, U y) { return (y < x) ? (x = y, true) : false; }

template <typename T, typename U> inline bool chmax(T &x, U y) { return (x < y) ? (x = y, true) : false; }

template<typename T> inline bool range(T l, T x, T r){ return l <= x && x < r; }

} // namespace noya2
#line 8 "/Users/noya2/Desktop/Noya2_library/template/template.hpp"

#define rep(i,n) for (int i = 0; i < (int)(n); i++)
#define repp(i,m,n) for (int i = (m); i < (int)(n); i++)
#define reb(i,n) for (int i = (int)(n-1); i >= 0; i--)
#define all(v) (v).begin(),(v).end()

using ll = long long;
using ld = long double;
using uint = unsigned int;
using ull = unsigned long long;
using pii = pair<int,int>;
using pll = pair<ll,ll>;
using pil = pair<int,ll>;
using pli = pair<ll,int>;

namespace noya2{

/*　~ (. _________ . /)　*/

}

using namespace noya2;


#line 2 "c.cpp"


void solve(){
    int n, m; in(n,m);
    vector<ld> a(n); in(a);
    vector<ld> rui(n+1,0);
    rep(i,n) rui[i+1] = rui[i] + a[i];
    auto get = [&](int l, int r){
        return (rui[r] - rui[l]) / (r - l);
    };
    vector<vector<ld>> dp(n+1,vector<ld>(n+1,-1e18));
    dp[0][0] = 0;
    rep(i,n){
        rep(j,n){
            rep(k,i+1){
                chmax(dp[i+1][j+1],dp[k][j] + get(k,i+1));
            }
        }
    }
    ld ans = -1e18;
    rep(i,m+1) chmax(ans,dp[n][i]);
    out(ans);
}

int main(){
    int t = 1; //in(t);
    while (t--) { solve(); }
}
accuracy: 1
time_ms: 260
memory_kb: 7096
final_rank: 18

code_snippet: //#define _GLIBCXX_DEBUG
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
//using uLL = unsigned __int128;
using str = string;
template <typename T> 
using pqg = priority_queue<T, vector<T>, greater<T>>;
template <typename T>
using pq = priority_queue<T>;
template <typename T>
using vec = vector<T>;
using pll = pair<long long, long long>;
using pii = pair<int, int>;
using vvvvl = vector<vector<vector<vector<ll>>>>;
using vvvi = vector<vector<vector<int>>>;
using vvvl = vector<vector<vector<ll>>>;
using vvvc = vector<vector<vector<char>>>;
using vvvd = vector<vector<vector<double>>>;
using vvi = vector<vector<int>>;
using vvl = vector<vector<ll>>;
using vvc = vector<vector<char>>;
using vvp = vector<vector<pair<ll, ll>>>;
using vvb = vector<vector<bool>>;
using vvd = vector<vector<double>>;
using vp = vector<pair<ll, ll>>;
using vi = vector<int>;
using vl = vector<ll>;
using vu = vector<unsigned long long>;
using vc = vector<char>;
using vb = vector<bool>;
using vd = vector<double>;
#define vvvm  vector<vector<vector<mint>>>
#define vvm  vector<vector<mint>>
#define vm  vector<mint>
template <typename T1, typename T2>
using umap = unordered_map<T1, T2>;
template <typename T>
using uset = unordered_set<T>;
#define rep(i, s, f) for(long long i = s; i <= f; i++)
#define rep1(i, s, f) for(long long i = s; i <= f; i++)
#define per(i, s, f) for(long long i = s; i >= f; i--)
#define per1(i, s, f) for(long long i = s; i >= f; i--)
#define eb(a) emplace_back(a)
#define pb(a) push_back(a)
#define all0(x) (x).begin() ,(x).end()
#define all(x) (x).begin() + 1, (x).end()
#define ins(x, l, r) (l <= x && x <= r)
#define ENDL '\n'
////////////////////////////////////////////////////////////////////////////////////////////////////////////
//これが本当の組み込み関数ってね（笑）
template <typename T>
int LB(vector<T> &A, T x) {
    return lower_bound(A.begin(), A.end(), x) - A.begin();
}

template <typename T>
int UB(vector<T> &A, T x) {
    return upper_bound(A.begin(), A.end(), x) - A.begin();
}
template <typename T>
void UNIQUE(vector<T> &A, int indexed) {
    sort(A.begin() + indexed, A.end());
    A.erase(unique(A.begin() + indexed, A.end()), A.end());
}

template <typename T>
vector<T> erase(vector<T>& A, T& x) {
	vector<T> res;
	for(T a : A) if(a != x) res.emplace_back(a);
	return res;
}
string split(string& S, int l, int r) {
	return S.substr(l, r - l + 1);
}

int msb(long long a) {
    if(a == 0) return -1;
    return 64 - int(__builtin_clzll(a));
}
template<typename T = long long>
void chmin(T &a, T b) {
    a = min(a, b);
}
template<typename T = long long>
void chmax(T &a, T b) {
    a = max(a, b);
}
//////////////////////////////////////////////////////////////////////
//数学系
///////////////////////////////////////////////////////////////////////
ll extgcd (ll a, ll b,  ll &x, ll &y) {
    if(b == 0) { x = 1;y = 0;return a;}
    ll d = extgcd(b, a%b, y, x);
    y -= a/b * x;
    return d;
}
template <typename T>
T ceil__(T a, T b) {
    assert(b != 0);
    if(a % b == 0) return a / b;
    if((a <= 0 && b < 0) || (a >= 0 && b > 0)) return a/b + 1;
    else return a / b;
}
template <typename T>
T floor__(T a, T b) {
    assert(b != 0);
    if(a % b == 0) return a / b;
    if((a <= 0 && b < 0) || (a >= 0 && b > 0)) return a/b;
    else return a/b - 1;
}
ll modpow(ll x, ll y, ll mod) {
    if(x > mod) x %= mod;
    if(y == 0) return 1;
    ll res = modpow(x, y >> 1, mod);
    res = res * res % mod;
    if(y & 1) res *= x, res %= mod;
    return res;
}
ll sqrt__(ll a) {
    ll l = 0;
    ll r = 3037000499LL;
    while(l < r) {
        ll mid = (l + r + 1) / 2;
        if(mid * mid <= a) l = mid;
        else r = mid - 1;
    }
    return l;
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//グローバル変数を置くところ
//#pragma GCC optimize("O3")
//#pragma GCC optimize("unroll-loops")
//#pragma GCC optimize "trapv" //お祈り。変数同士の演算でのみ感知。代入や、 a *= 10000 では感知しない。
const ll big = 1001001001;
const ll BIG = 1001001001001001001LL;
const double pi = 3.141592653589793;
vl dx{0, 1, 0, -1, 0, 1, 1, -1, -1};  // 座標平面において、(番兵) → ↓ ← ↑  ※ 右から時計回り 注 : グリッド or 座標で上下は反転する。
vl dy{0, 0, -1, 0, 1, 1, -1, -1, 1};
//const ll mod = 1000000007;
//const ll mod = 998244353;
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/*


*/

using vd = vector<double>;
using vvd = vector<vector<double>>;

void solve() {
	int N, M;
	cin >> N >> M;
	vd A(N+1);
	rep(i,1,N) cin >> A[i];
	vd S(N+1);
	rep(i,1,N) S[i] = S[i-1] + A[i];



	vvd dp(N+1, vd(N+1, -BIG));

	rep(i, 1, N) {
		rep(j, 1, i) {
			if(j==1) dp[i][j] = S[i]/i;
			else {
				rep(l, 2, N) {//[l, i]を一緒にする。
				    double now = S[i] - S[l-1];
					now /= (i - l + 1);
					chmax<double>(dp[i][j], now + dp[l-1][j-1]);
				}
			}

		}
	}

	cout << dp[N][M] << endl;

	
	
    

    
    

}



int main() {
    ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    cout << fixed << setprecision(15);
    ll T = 1;
    //cin >> T;
    rep(i, 1, T) {
        solve();
    }
    return 0;
}



/*

- WA : 違法な読み替えをしていないか・違法な操作をしていないか
・実装が重そうな時は確認する 一度飛ばしても良い
・嘘を吐いていないかの他に、違法な操作をしていないかもチェックする。特にふわっとした操作は危ない
  -区間をちょっと伸ばす←端の時、伸ばす余地はあるか
  -選択肢のうち、どれでも良いから消す←本当にどれでも良いか 場合分けを挟んでないか そもそも消せる要素は存在するか
  -適当に割り振る←順番を区別する必要があるかもしれない
・答えの候補にはならないからと言って最初から無かったことにすると、その要素による制約も無視してしまう事がある。
・dpで途中までは辻褄が合っても、最後に分岐するので纏めてはいけない遷移というのがある



[整理パート] とりあえずやること
・必ずやらなければいけない操作は、順番が許すなら最初にやる
・確実にかかる費用があるなら、その費用は確定した上で他にかかる費用を最小化する。
・要素と制約をグラフで表してみる
  -関係がある要素間を辺で結び、制約上独立な要素集合ごとに見る
    ・二部グラフ > functional graph 出次数1なら functional graphの方が見えやすいかも
  -遷移を図で表現し、使いまわしたりできないか見る
  -グラフの2頂点に注目するなら、その2頂点を引っ張る or 2頂点のlcaに注目する。
・制約を「全ての要素についてoo ⇔ (1<=i<=N)で、iについてoo」といったように、独立なものに言い換えた方がやりやすいこともある
  -特に、bit演算が絡む時は、整数をbit毎に見る事で1つの制約を扱いやすい制約30個に分解できる(bit演算以外の時は、この30個が複雑に絡み合う可能性が高くなる)

・スコア・問題を数式で表現する。多少複雑そうでも、試みるぐらいはする。
  -複雑そうだし、役に立たないのでは？という直感はゴミ
  
・操作を制約に合わせて言い換える・制約を操作に合わせて言い換える。言い換えない方が良いことは多々ある。
  -全てがの要素が等しい⇔差分列が全て0
  -階差数列⇔差分列の要素の値が等しい
  -配列の、まとまった領域に対するよく分からない操作は(1)何ができるか調べる(2)何が作れるのか調べる(3)差分列に注目(4)modMごとに分けてみる(5)累積和列に注目

・よくわからないもの・扱いづらいものを言い換える。
  -特に、慣れ親しんだ制約も、問題設定によってより扱いやすい形に言い換えられるかもしれない（例：グラフが連結)
・強い制約は、数え上げ・最適化・クエリ・ゲーム共に良い性質を生みやすいので注目する
  -制約に具体的な数値が登場している←適当に解をいじると何となく性質が見えることが多い
  -強い言葉を使われた・補集合が単純なものを提示されたら、ほう助を疑う。 
     -「値がxに一致しない」
     -「1つ以上存在する・1つも存在しない」
     -「1回以上発生する・1度も発生しない」
     

[観察]  様々な解法も、実際試さないとそれで解けると分からないことは多い。
[]それらしい筋を書いておく → 一本道でもない限り、それぞれの解法をある程度並行して考える。 また、困ったら全部の筋を試す。
  -特に、最初に建てた方針は等しく皆大事にする。1つにのめり込むことのない様に。
[]１5分毎ぐらいに進捗を確認する←考察が進んでいない・闇雲な無限整理編に入っていたら、その筋はやばい可能性が高いので他の筋があれば変える。あるいは飛ばす。
	-数学的な式を満たす値は、グラフを書いたり列挙をすることで性質が見えることもある。
  -数学的な求値は、意味づけによる計算量削減が難しいが、漸化式的な発想が役に立つことが多い。
    ・combinationが入るΣ
	-満たすものが少なそうな制約は、同時に探索空間も小さくできるかも
  -問題設定によって、探索空間そのものが狭くなっている場合がある。


[やる事ない]
・取れる選択肢がある限り全て試す。一つに固執せず、横断的に見る。
・過去の問題の手法を当てはめてみる。
・やばい見た目してても、スコアなどを数式で表すことを試みてみる
  -貪欲や何かが見えるかも
・逆に、何ができる・成り立っているなら問題を解けるかを考える。それが実際できることを疑う。
  -大胆予想が正しい
    ・大胆予想：特殊ケース（c=0等)の時の答えと、一般のケースの答えが一致する
    ・大胆予想：必要十分条件がooである


[やる事ない：数え上げ周り] どれかに当てはまれば、解ける。そして、だいたいどれか。
[0]状態を保ちながら、順々に探索していける [1]探索空間そのものに特徴がある [2]解に特徴がある [3]探索順を変える [4]全探索の対象を全て試す [5]主客逆転 [6]昔計算した結果を再利用できる
  -[0]持つべき情報...「その状態から後にどの様に分岐すか」を求めるのに必要な情報 
  -[3]でかい方から、深い方から、DAGで先端になっている・或いは葉になっている所から、全てを逆に言い換えて時系列的に後ろから ... で、構造が単純になることがある。
    -特に,左から決定していく探索について:「要素ごとに寄与が分解できない」という時も、新たに要素が増えることによる"全体の寄与の変化"が高速に計算できれば解ける。主客転倒と近いかもしれない。
  -[4]固定するものの数が多くても、何かを固定した時の場合の和が綺麗に表せれば、固定するものを纏めて計算できる。
  -[5]演算が+やxorなどの分解して良いやつの時


[やる事ない：最適化周り]
[0]順番を保ちながら、順々に探索していける [1]探索空間そのものに特徴がある [2]解の形を絞れる [3]答えを決め打って判定問題 [4]最悪ケース・最良ケースを纏めると、スコアに関わる本質部分がわかって、場合分けが進む/上界・下界が絞れる。 
[5]条件を満たす為の操作・構築として、具体的な操作考を考え、改善していく [6]探索順を変える [7]探索の軸を変える [8]特殊ケースの解方が一般ケースでも最適 [9]自由度を無視しても最適解が構築できる
  -[0]特に、操作が順番に寄らない時は選択肢としてあり得る。順番に寄る時は難しいかもしれない。
  -[0]条件を満たしながら最適化という時、条件が簡潔・存在しないならばそれに至るまでにありうる状態を全て状態として持つdpが可能かもしれない。
    -例:連続とは限らない部分文字列としてabcを含まない/含む様にする時の最小操作回数
  -[3]答えに限らず、何かが定まれば貪欲がありそうという時に有効（目標とする値・何かの上限...)
  -[4]最悪・最良の疑いがある解を見つけたら、最悪である必要条件を考えて、最悪ケースを特徴づけする。その後、２番目に最悪ケースについて同じことをしたり、他のケースに含まれる部分的な最悪ケースが支配的になっていることを考える。
  -[5]ooを満たす為の「最小の操作回数」や「コストがC以下の操作」を聞かれた際、「ooを満たす様な具体的な操作・構築」を考える事になる。
    -初期状態が満たす可能性があるなら、それを省く。条件が"ooでない"、の時、初期状態がooであるという制約がつく等嬉しい。
    -同じ条件を満たす様な操作・構築の中では、自由度がより高いのが良い。
    -後から調整可能なのは後回し。支配的なのは出来るだけ最初に。
    -やってはいけない事を禁止。何ができるか。
    -最小化等を考えずに、ともかく与えられた操作・制約・上限コストでどの様な解が作れるか。([1])
    -この構築で可能か？を探る際は、最悪ケースで実験する。穴がある解を未然に防ぐ。
    -それっぽい操作を考えたが、できない事がある→できる場合・できない場合を特徴づける。
      -出来ない条件を探る過程で、本質的な必要十分に辿り着くかもしれない。 例：木の深さの偶奇が関わる→二部グラフにした時... , 二部グラフにできない時...
      -より条件を絞った状態で考えられる。
  -[6]でかい方から、深い方から、DAGで先端になっている・或いは葉になっている所から、全てを逆に言い換えて時系列的に後ろから ... で、貪欲が見えたり構造が単純になることがある。
  -[7]今給油するか？では無く、「ここで必要なガソリンはどこで給油するか？
・「最適な操作順」や「操作順に関する貪欲」なんてわからないという時、一旦引いて「ooの分のコストは確実にかかる」等を整理すると、手順を陽に明かさずとも最適な答えがわかることはある。
・bit演算がメインなら、bitごとにみる。特に、msbに注目する。（数が少ないので必要条件になりやすい・大きくする時の貪欲はとにかく上を立てる)
・関係をグラフに起こしてあると気づきやすいこともある
・スコアを数学的な式で表すことを試みたか
・差分を計算するなら、最初から差分計算の処理のみで答えを計算した方が良い。最初を愚直でやると情報をロストする可能性があるし、愚直の枠組みに囚われる事もある。
・文字列周りのアルゴリズムは、昔の結果を利用して高速に計算する方法を述べているのであって、「回文がminになるoo」を求めるのには役に立たない？

[やる事ない：クエリ]
[1]1回のクエリが高速に計算できる  [2]最終的に求める値がそれぞれ高速に計算できる [3]差分が計算できる [4]最終的に求める値が並列に計算できる 
  -[1]確かに1回のクエリが解けた事を確認してから更新を考える事  解ける前から「直観的に必要そうな情報」の更新を考えたりしない (制約を元に、計算量をメタ読みするのは良い)

[やる事ない：操作列の長いシュミレーション周り]
[1]周期性がある  [2]結果を基準に見る, [3]再帰的に計算できる [4]時間のかかる操作の回数が少ない
  -[2]...操作を順々にしていくのでは無く、求めるものを直接求めにいく
   -「(削除の)シュミレーションを高速にやる」と「要素が最後まで残る必要条件をみる」
  -[1],[3] 綺麗な構造になっていれば
  -[4]...シュミレーションを実行するのに必要な計算を列挙する。重いやつのうち、実際にやらなければならない回数が実は少ないなど。



[高速化ネタ]
・lcmを含む式はgcdの式にする
・操作のどれを1段階とするかは自由に決めて良い(DPと同じ)。特に、操作をさらに細かくすることで1回を軽くすることもある。
・dpやシュミレーションで、段階によって遷移(計算)の本数が変化する時、貰う・配るを両立することでO(N√N)  注意：貰っても配っても良い時のみ。具体的に、期待値ではダメ。
・「全探索する軸が違うのに計算量同じな解法のペアがある」 と 「それぞれに得意・貪欲によりさらに計算量を減らせる範囲だけを計算させることでO(N√N)
 -自由度が2つ以上あるときなど 例：「数列が等差数列である ... 「一つ、数列の値を指定する」と「公差を指定する」
・「明らかに調べなくて良い」「これだけは別途楽に計算できる」事を事前に省いた結果、実は計算量を劇的に減らすことがある。主に最適化の文脈。
  -最悪ケースを考えると気づくかもしれない
・答えの個数・値が小さいなら、探索範囲をせばせて良いかも
・「bit/素因数ごとに分ける」と「分けずにまとめて計算する」

*/
accuracy: 1
time_ms: 70
memory_kb: 5280
final_rank: 9

code_snippet: #include <bits/stdc++.h>
#pragma region //Read macro
    #define GET_1_ARG(TYPE, ARG); TYPE ARG; std::cin >> ARG;
    #define GET_2_ARG(TYPE, ARG, ...) GET_1_ARG(TYPE, ARG) GET_1_ARG(TYPE, __VA_ARGS__)
    #define GET_3_ARG(TYPE, ARG, ...) GET_1_ARG(TYPE, ARG) GET_2_ARG(TYPE, __VA_ARGS__)
    #define GET_4_ARG(TYPE, ARG, ...) GET_1_ARG(TYPE, ARG) GET_3_ARG(TYPE, __VA_ARGS__)
    #define GET_5_ARG(TYPE, ARG, ...) GET_1_ARG(TYPE, ARG) GET_4_ARG(TYPE, __VA_ARGS__)
    #define GET_6_ARG(TYPE, ARG, ...) GET_1_ARG(TYPE, ARG) GET_5_ARG(TYPE, __VA_ARGS__)
    #define GET_7_ARG(TYPE, ARG, ...) GET_1_ARG(TYPE, ARG) GET_6_ARG(TYPE, __VA_ARGS__)
    #define GET_8_ARG(TYPE, ARG, ...) GET_1_ARG(TYPE, ARG) GET_7_ARG(TYPE, __VA_ARGS__)
    #define GET_9_ARG(TYPE, ARG, ...) GET_1_ARG(TYPE, ARG) GET_8_ARG(TYPE, __VA_ARGS__)
    #define GET_10_ARG(TYPE, ARG, ...) GET_1_ARG(TYPE, ARG) GET_9_ARG(TYPE, __VA_ARGS__)

    #define GET_MACRO(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,NAME,...) NAME
    #define read(TYPE, ...) GET_MACRO(__VA_ARGS__, GET_10_ARG, GET_9_ARG, GET_8_ARG, GET_7_ARG, GET_6_ARG, GET_5_ARG, GET_4_ARG, GET_3_ARG, GET_2_ARG, GET_1_ARG)(TYPE, __VA_ARGS__)

    #define readv(TYPE, NAME, SIZE) std::vector<TYPE> NAME(SIZE); for (long long i = 0; i < SIZE; i++) std::cin >> NAME[i];
    #define readvv(TYPE, NAME, H, W) std::vector<std::vector<TYPE>> NAME(H, std::vector<TYPE>(W)); for (long long i = 0; i < H; i++) for (long long j = 0; j < W; j++) std::cin >> NAME[i][j];
#pragma endregion //Read macro

#pragma region //Other macro
    #define rep(i, n) for (ll i = 0; i < n; i++)
    #define reps(i, start, goal, diff) for (ll i = start; i != goal; i += diff)
    #define all(a) a.begin(), a.end()
//    #define chmax(a, b) a = std::max(a, b)
//    #define chmin(a, b) a = std::min(a, b)
#pragma endregion //Other macro
using namespace std;


using ll = long long;
using vll = std::vector<ll>;
using vvll = std::vector<std::vector<ll>>;

#define getsum(i, j) (cumul[j] - cumul[i])

int main() {
    read(ll, n, m);
    readv(ll, a, n);
    vll cumul(n+1, 0);
    rep(i, n) {
        cumul[i+1] = cumul[i] + a[i];
    }
    vector<vector<double>> dp(n+1, vector<double>(n+1, 0));
    rep(i, n) {
        dp[i+1][0] = numeric_limits<double>::min();
    }
    rep(i, n+1) {
        rep(j, n) {
            rep(k, i) {
                if (j == 0 && i != 0 && k != 0) continue;
                ll sum = getsum(k, i);
                double avg = double(sum) / (i-k);
                dp[i][j+1] = max(dp[i][j+1], dp[k][j] + avg);
            }
        }
    }
    /*
    rep(i, n+1) {
        rep(j, n+1) {
            cout << dp[i][j] << " ";
        }
        cout << endl;
    }
    */
    double ans = 0;
    rep(i, m+1) {
        ans = max(ans, dp[n][i]);
    }
    cout << fixed << setprecision(10) << ans << endl;
}
accuracy: 1
time_ms: 120
memory_kb: 5552
final_rank: 16

code_snippet: // author: hotman78
// date: 2024/04/12-18:29:40

// --- begin raw code -----------------
// #include"cpplib/util/template.hpp"
// 
// void solve(){
//     lint n,m;
//     cin>>n>>m;
//     vec a(n);
//     rep(i,n)cin>>a[i];
//     vec b(n+1);
//     rep(i,n)b[i+1]=b[i]+a[i];
//     vector<vector<double>>dp(n+1,vector<double>(m+1,-INF));
//     dp[0][0]=0;
//     rep(i,n){
//         rep(j,i+1,n+1){
//             rep(k,m){
//                 chmax(dp[j][k+1],dp[i][k]+(b[j]-b[i])*1./(j-i));
//             }
//         }
//     }
//     double ans=-INF;
//     rep(i,m+1){
//         chmax(ans,dp[n][i]);
//     }
//     cout<<ans<<endl;
// }
// 
// int main(){
//     solve();
// }
// --- end raw code -----------------

#line 2 "cpplib/util/template.hpp"
#ifdef LOCAL
#define _GLIBCXX_DEBUG
#endif
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("avx2")
#include <bits/stdc++.h>
using namespace std;
#line 1 "cpplib/util/ioutil.hpp"
// template <class Head,class... Args>
// std::ostream& output(std::ostream& out,const Head& head,const Args&... args){
//     out>>head;
//     return output(head,args...);
// }
// template <class Head>
// std::ostream& output(std::ostream& out,const Head& head){
//     out>>head;
//     return out;
// }

template <typename T, typename E>
std::ostream &operator<<(std::ostream &out, std::pair<T, E> v) {
    out << "(" << v.first << "," << v.second << ")";
    return out;
}

// template <class... Args>
// ostream& operator<<(ostream& out,std::tuple<Args...>v){
//     std::apply(output,v);
//     return out;
// }
#line 11 "cpplib/util/template.hpp"
struct __INIT__ {
    __INIT__() {
        cin.tie(0);
        ios::sync_with_stdio(false);
        cout << fixed << setprecision(15);
    }
} __INIT__;
typedef long long lint;
constexpr long long INF = 1LL << 60;
constexpr int IINF = 1 << 30;
constexpr double EPS = 1e-10;
#ifndef REACTIVE
#define endl '\n';
#endif
typedef vector<lint> vec;
typedef vector<vector<lint>> mat;
typedef vector<vector<vector<lint>>> mat3;
typedef vector<string> svec;
typedef vector<vector<string>> smat;
template <typename T> using V = vector<T>;
template <typename T> using VV = V<V<T>>;
#define output(t)                                                              \
    {                                                                          \
        bool f = 0;                                                            \
        for (auto val : (t)) {                                                 \
            cout << (f ? " " : "") << val;                                     \
            f = 1;                                                             \
        }                                                                      \
        cout << endl;                                                          \
    }
#define output2(t)                                                             \
    {                                                                          \
        for (auto i : t)                                                       \
            output(i);                                                         \
    }
#define debug(t)                                                               \
    {                                                                          \
        bool f = 0;                                                            \
        for (auto i : t) {                                                     \
            cerr << (f ? " " : "") << i;                                       \
            f = 1;                                                             \
        }                                                                      \
        cerr << endl;                                                          \
    }
#define debug2(t)                                                              \
    {                                                                          \
        for (auto i : t)                                                       \
            debug(i);                                                          \
    }
#define loop(n) for (long long _ = 0; _ < (long long)(n); ++_)
#define _overload4(_1, _2, _3, _4, name, ...) name
#define __rep(i, a) repi(i, 0, a, 1)
#define _rep(i, a, b) repi(i, a, b, 1)
#define repi(i, a, b, c)                                                       \
    for (long long i = (long long)(a); i < (long long)(b); i += c)
#define rep(...) _overload4(__VA_ARGS__, repi, _rep, __rep)(__VA_ARGS__)
#define _overload3_rev(_1, _2, _3, name, ...) name
#define _rep_rev(i, a) repi_rev(i, 0, a)
#define repi_rev(i, a, b)                                                      \
    for (long long i = (long long)(b)-1; i >= (long long)(a); --i)
#define rrep(...) _overload3_rev(__VA_ARGS__, repi_rev, _rep_rev)(__VA_ARGS__)

#define all(n) begin(n), end(n)
template <typename T, typename E> bool chmin(T &s, const E &t) {
    bool res = s > t;
    s = min<T>(s, t);
    return res;
}
template <typename T, typename E> bool chmax(T &s, const E &t) {
    bool res = s < t;
    s = max<T>(s, t);
    return res;
}
const vector<lint> dx = {1, 0, -1, 0, 1, 1, -1, -1};
const vector<lint> dy = {0, 1, 0, -1, 1, -1, 1, -1};
#define SUM(v) accumulate(all(v), 0LL)
#if __cplusplus >= 201703L
template <typename T, typename... Args>
auto make_vector(T x, int arg, Args... args) {
    if constexpr (sizeof...(args) == 0)
        return vector<T>(arg, x);
    else
        return vector(arg, make_vector<T>(x, args...));
}
#endif
#define bit(n, a) ((n >> a) & 1)
#define extrep(v, ...) for (auto v : make_mat_impl({__VA_ARGS__}))
vector<vector<long long>> make_mat_impl(vector<long long> v) {
    if (v.empty())
        return vector<vector<long long>>(1, vector<long long>());
    long long n = v.back();
    v.pop_back();
    vector<vector<long long>> ret;
    vector<vector<long long>> tmp = make_mat_impl(v);
    for (auto e : tmp)
        for (long long i = 0; i < n; ++i) {
            ret.push_back(e);
            ret.back().push_back(i);
        }
    return ret;
}
using graph = vector<vector<int>>;
template <typename T> using graph_w = vector<vector<pair<int, T>>>;

#if __cplusplus >= 201703L
constexpr inline long long powll(long long a, long long b) {
    long long res = 1;
    while (b--)
        res *= a;
    return res;
}
#endif

template <typename T, typename E>
pair<T, E> &operator+=(pair<T, E> &s, const pair<T, E> &t) {
    s.first += t.first;
    s.second += t.second;
    return s;
}
template <typename T, typename E>
pair<T, E> &operator-=(pair<T, E> &s, const pair<T, E> &t) {
    s.first -= t.first;
    s.second -= t.second;
    return s;
}
template <typename T, typename E>
pair<T, E> operator+(const pair<T, E> &s, const pair<T, E> &t) {
    auto res = s;
    return res += t;
}
template <typename T, typename E>
pair<T, E> operator-(const pair<T, E> &s, const pair<T, E> &t) {
    auto res = s;
    return res -= t;
}
#define BEGIN_STACK_EXTEND(size)                                               \
    void *stack_extend_memory_ = malloc(size);                                 \
    void *stack_extend_origin_memory_;                                         \
    char *stack_extend_dummy_memory_ = (char *)alloca(                         \
        (1 + (int)(((long long)stack_extend_memory_) & 127)) * 16);            \
    *stack_extend_dummy_memory_ = 0;                                           \
    asm volatile("mov %%rsp, %%rbx\nmov %%rax, %%rsp"                          \
                 : "=b"(stack_extend_origin_memory_)                           \
                 : "a"((char *)stack_extend_memory_ + (size)-1024));
#define END_STACK_EXTEND                                                       \
    asm volatile("mov %%rax, %%rsp" ::"a"(stack_extend_origin_memory_));       \
    free(stack_extend_memory_);
int floor_pow(int n) { return n ? 31 - __builtin_clz(n) : 0; }
#line 2 "main.cpp"

void solve() {
    lint n, m;
    cin >> n >> m;
    vec a(n);
    rep(i, n) cin >> a[i];
    vec b(n + 1);
    rep(i, n) b[i + 1] = b[i] + a[i];
    vector<vector<double>> dp(n + 1, vector<double>(m + 1, -INF));
    dp[0][0] = 0;
    rep(i, n) {
        rep(j, i + 1, n + 1) {
            rep(k, m) {
                chmax(dp[j][k + 1], dp[i][k] + (b[j] - b[i]) * 1. / (j - i));
            }
        }
    }
    double ans = -INF;
    rep(i, m + 1) { chmax(ans, dp[n][i]); }
    cout << ans << endl;
}

int main() { solve(); }
accuracy: 1
time_ms: 40
memory_kb: 5224
final_rank: 4

code_snippet: // #ifndef ONLINE_JUDGE
#if __has_include("all.h")

#include "all.h"

#else

#include <bits/extc++.h>

// #include <atcoder/all>

#endif

using ll = long long int;

template <class T>
bool chmin(T &x, const T val) {
  if (x > val) {
    x = val;
    return true;
  } else {
    return false;
  }
}

template <class T>
bool chmax(T &x, const T val) {
  if (x < val) {
    x = val;
    return true;
  } else {
    return false;
  }
}

template <class T, class U>
std::istream &operator>>(std::istream &is, std::pair<T, U> &p) {
  return is >> p.first >> p.second;
}

template <class... T>
std::istream &operator>>(std::istream &is, std::tuple<T...> &tpl) {
  std::apply([&](auto &&...args) { (is >> ... >> args); }, tpl);
  return is;
}

template <class T>
std::istream &operator>>(std::istream &is, std::vector<T> &v) {
  for (T &x : v) is >> x;
  return is;
}

// template <class mint, atcoder::internal::is_static_modint_t<mint> * =
// nullptr> std::ostream &operator<<(std::ostream &os, const mint &v) {
//   return os << v.val();
// }

template <class T>
std::ostream &operator<<(std::ostream &os, const std::vector<T> &v) {
  for (int i = 0; i < v.size(); i++)
    os << v[i] << (i == v.size() - 1 ? "" : " ");
  return os;
}

struct Initialization {
  Initialization() {
    std::ios_base::sync_with_stdio(false);
    std::cin.tie(nullptr);
  }
} initialization;

constexpr std::pair<int, int> dir[] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};

template <typename T>
using infs = std::numeric_limits<T>;

template <typename T>
class factorials {
 public:
  static size_t n;
  static std::vector<T> fact, inv_fact;

  static void extend(size_t m) {
    if (m <= n) return;
    fact.resize(m + 1);
    inv_fact.resize(m + 1);
    for (size_t i = n + 1; i <= m; i++) fact[i] = fact[i - 1] * i;
    inv_fact[m] = fact[m].inv();
    for (size_t i = m; i > n + 1; i--) inv_fact[i - 1] = inv_fact[i] * i;
    n = m;
  }

  static T inv(int k) {
    extend(k);
    return inv_fact[k];
  }

  static T get(int k) {
    extend(k);
    return fact[k];
  }

  static T perm(int n, int k) {
    if (n < k) return 0;
    if (k < 0) return 0;
    extend(n);
    return fact[n] * inv_fact[n - k];
  }

  static T choose(int n, int k) {
    if (n < k) return 0;
    if (k < 0) return 0;
    extend(n);
    return fact[n] * inv_fact[n - k] * inv_fact[k];
  }
};

template <typename T>
size_t factorials<T>::n = 0;

template <typename T>
std::vector<T> factorials<T>::fact = {1};

template <typename T>
std::vector<T> factorials<T>::inv_fact = {1};

// template <typename T>
// class fps {
//   std::vector<T> v;
//
//  public:
//   using value_type = T;
//   using reference = T &;
//   using const_reference = const T &;
//   using iterator = typename std::vector<T>::iterator;
//   using const_iterator = typename std::vector<T>::const_iterator;
//
//   size_t size() const { return v.size(); }
//
//   const std::vector<T> &data() const { return v; }
//
//   explicit fps(int n) : v(n) {}
//
//   fps(const std::vector<T> &v) : v(v) {}
//   fps(std::vector<T> &&v) : v(v) {}
//
//   template <class InputIterator>
//   fps(InputIterator first, InputIterator last) : v(first, last) {}
//
//   void resize(int n) { v.resize(n); }
//
//   T &operator[](int i) { return v[i]; }
//
//   iterator begin() { return v.begin(); }
//
//   iterator end() { return v.end(); }
//
//   fps diff() {
//     std::vector<T> res(v.size() - 1);
//     for (int i = 0; i < res.size(); i++) res[i] = v[i + 1] * (i + 1);
//     return fps(res);
//   }
//
//   fps integral() {
//     std::vector<T> res(v.size() + 1);
//     for (int i = 0; i < v.size(); i++) res[i + 1] = v[i] / (i + 1);
//     return fps(res);
//   }
//
//   fps inv(int deg = -1) {
//     assert(v[0] != 0);
//
//     if (deg == -1) deg = size();
//     std::vector<T> res(deg);
//
//     res[0] = v[0].inv();
//
//     for (int d = 1; d < deg; d <<= 1) {
//       std::vector<T> f(2 * d), g(2 * d);
//
//       std::copy(v.begin(), v.begin() + std::min(2 * d, (int)v.size()),
//                 std::back_inserter(f));
//       std::copy(res.begin(), res.begin() + d, std::back_inserter(g));
//
//       atcoder::internal::butterfly(f);
//       atcoder::internal::butterfly(g);
//
//       for (int i = 0; i < 2 * d; i++) f[i] *= g[i];
//
//       atcoder::internal::butterfly_inv(f);
//
//       for (int i = 0; i < d; i++) f[i] = 0;
//
//       atcoder::internal::butterfly(f);
//
//       for (int i = 0; i < 2 * d; i++) f[i] *= g[i];
//
//       atcoder::internal::butterfly_inv(f);
//
//       for (int i = d; i < std::min(2 * d, deg); i++) res[i] = -f[i];
//     }
//
//     res.resize(deg);
//
//     return res;
//   }
//
//   fps shift(T c) {
//     std::vector<T> res(size()), ifacts(size());
//
//     T x = 1;
//
//     for (int i = 0; i < size(); i++) {
//       ifacts[i] = x * factorials<T>::inv(i);
//       x *= c;
//     }
//
//     for (int i = 0; i < size(); i++) {
//       res[size() - 1 - i] = v[i] * factorials<T>::get(i);
//     }
//
//     res = atcoder::convolution(res, ifacts);
//
//     res.resize(size());
//
//     std::ranges::reverse(res);
//
//     for (int i = 0; i < size(); i++) {
//       res[i] *= factorials<T>::inv(i);
//     }
//
//     return res;
//   }
//
//   fps operator-() {
//     fps res(v.size());
//     for (int i = 0; i < v.size(); i++) res[i] = -v[i];
//     return res;
//   }
//
//   fps &operator+=(const fps &rhs) {
//     if (v.size() < rhs.v.size()) v.resize(rhs.v.size());
//     for (int i = 0; i < rhs.v.size(); i++) v[i] += rhs.v[i];
//     return *this;
//   }
//
//   fps &operator-=(const fps &rhs) {
//     if (v.size() < rhs.v.size()) v.resize(rhs.v.size());
//     for (int i = 0; i < rhs.v.size(); i++) v[i] -= rhs.v[i];
//     return *this;
//   }
//
//   fps &operator*=(const fps &rhs) {
//     return *this = atcoder::convolution(v, rhs.v);
//   }
//
//   fps &operator+=(const T &rhs) {
//     if (v.size() == 0) v.resize(1);
//     v[0] += rhs;
//     return *this;
//   }
//
//   fps &operator-=(const T &rhs) {
//     if (v.size() == 0) v.resize(1);
//     v[0] -= rhs;
//     return *this;
//   }
//
//   fps &operator*=(const T &rhs) {
//     for (int i = 0; i < v.size(); i++) v[i] *= rhs;
//     return *this;
//   }
//
//   fps &operator/=(const T &rhs) {
//     T rhs_inv = rhs.inv();
//     for (int i = 0; i < v.size(); i++) v[i] *= rhs_inv;
//     return *this;
//   }
//
//   friend fps operator+(const fps &lhs, const fps &rhs) {
//     return fps(lhs) += rhs;
//   }
//
//   friend fps operator-(const fps &lhs, const fps &rhs) {
//     return fps(lhs) -= rhs;
//   }
//
//   friend fps operator*(const fps &lhs, const fps &rhs) {
//     return fps(lhs) *= rhs;
//   }
//
//   friend fps operator+(const fps &lhs, const T &rhs) { return fps(lhs) +=
//   rhs; }
//
//   friend fps operator-(const fps &lhs, const T &rhs) { return fps(lhs) -=
//   rhs; }
//
//   friend fps operator*(const fps &lhs, const T &rhs) { return fps(lhs) *=
//   rhs; }
//
//   friend fps operator/(const fps &lhs, const T &rhs) { return fps(lhs) /=
//   rhs; }
//
//   friend fps operator+(const T &lhs, const fps &rhs) { return fps(rhs) +=
//   lhs; }
//
//   friend fps operator-(const T &lhs, const fps &rhs) {
//     return -(fps(rhs) -= lhs);
//   }
//
//   friend fps operator*(const T &lhs, const fps &rhs) { return fps(rhs) *=
//   lhs; }
// };

// using mint = atcoder::modint998244353;
// using mint = atcoder::modint1000000007;

// using fs = factorials<mint>;

int main() {
  int N, M;
  std::cin >> N >> M;
  std::vector<ll> a(N);
  std::cin >> a;

  std::vector dp(N + 1, std::vector(M + 1, -infs<double>::max()));

  dp[0][0] = 0;

  for (int i = 0; i < N; i++) {
    for (int j = 0; j < M; j++) {
      double sum = 0;
      for (int k = i; k < N; k++) {
        sum += a[k];
        chmax(dp[k + 1][j + 1], dp[i][j] + sum / (k - i + 1));
      }
    }
  }

  std::cout << std::fixed << std::setprecision(15) << dp[N][M] << std::endl;

  // for (int i = 0; i <= N; i++) {
  //   std::cerr << dp[i] << std::endl;
  // }
}
accuracy: 1
time_ms: 70
memory_kb: 5196
final_rank: 8

code_snippet: #include <bits/stdc++.h>

using namespace std;

void chmax(double &a, double b) {
  if (a < b) a = b;
}

int main() {
  cout << fixed << setprecision(6);

  int N, M;
  cin >> N >> M;
  
  vector<int> a(N);
  for (int i = 0; i < N; ++i) cin >> a[i];
  
  vector<vector<double>> dp(N + 1, vector<double>(M, 0));
  for (int j = 0; j < N + 1; ++j) {
    double sum_0 = 0;
    for (int i = 0; i < j; ++i) sum_0 += a[i];
    double sum_i = sum_0 ;
    for (int i = 0; i < j; ++i) {
      dp[j][0] = sum_0 / j;
      double d = sum_i / (j - i);
      for (int m = 1; m < M; ++m) {
        chmax(dp[j][m], dp[i][m - 1] + d);
      }
      sum_i -= a[i];
    }
  }
  cout << dp[N][M - 1] << endl;
}
accuracy: 1
time_ms: 30
memory_kb: 5540
final_rank: 3

code_snippet: #include <bits/stdc++.h>

using namespace std;

double val(int i, int j, vector<int> &a) {
  double sum = 0;
  for (int k = i; k < j; ++k) sum += a[k];
  return sum / (j - i);
}

void chmax(double &a, double b) {
  if (a < b) a = b;
}

int main() {
  cout << fixed << setprecision(6);

  int N, M;
  cin >> N >> M;
  
  vector<int> a(N);
  for (int i = 0; i < N; ++i) cin >> a[i];
  
  vector<vector<double>> dp(N + 1, vector<double>(M, 0));
  for (int j = 0; j < N + 1; ++j) {
    for (int i = 0; i < j; ++i) {
      dp[j][0] = val(0,j,a);
      double d = val(i,j,a);
      for (int m = 1; m < M; ++m) {
        chmax(dp[j][m], dp[i][m - 1] + d);
      }
    }
  }
  cout << dp[N][M - 1] << endl;
}
accuracy: 1
time_ms: 80
memory_kb: 5544
final_rank: 11

code_snippet: #include <iostream>
#include <iomanip>
#include <string>
#include <vector>

using namespace std ;
//using ll = long long ;

//const ll INF = 1LL<<60 ;
const int INF = 1<<30 ;

template<class T> void chmin(T& a, T b) {
    if ( a > b ) a = b ;
}
template <class T> void chmax(T& a, T b) {
    if ( a < b ) a = b ;
} 

int main() {
    int N, M; cin >> N >> M ;
    vector<double> a(N), c(N+1, 0) ; 
    for ( int i=0; i<N; i++ ) {
        cin >> a[i] ;
        c[i+1] = c[i] + a[i] ;
    }// c[i] = a[0] + ... + a[i-1]
    
    vector<vector<double> > dp(N+1, vector<double>(M+1, 0)) ;
    // dp[i][j] : 0~i-1を1<=j<=M分割した時の最大スコア
    dp[0][0] = 0 ;

    for ( int i=1; i<=N; i++ ) {
        for ( int j=1; j<=min(M, i); j++ ) {
            for ( int k=0; k<=i; k++ ) {
                if ( j-1 == 0 ) chmax(dp[i][j], dp[0][0] + c[i]/((double)i)) ;
                if ( i-k >= j-1 && j-1 > 0 ) chmax(dp[i][j], dp[i-k][j-1] + (c[i] - c[i-k])/((double)k)) ;
            }
        }
    }
    cout << setprecision(7) << dp[N][M] << endl ;

    /*for ( int i=0; i<=N; i++ ) {
        for ( int j=0; j<=M; j++ ) printf("%2.3f ", dp[i][j]) ;
        cout << endl ;
    }*/
}
accuracy: 1
time_ms: 80
memory_kb: 5036
final_rank: 10

code_snippet: #include<bits/stdc++.h>
using namespace std;
using ll = long long;

int main(){
  ll N,M;
  cin >> N >> M;
  vector<ll> A(N);
  for(int i=0; i<N; i++) cin >> A[i];
  vector<vector<long double>> dp(N+1,vector<long double>(M+1, -1));
  dp[0][0] = 0;
  for(int i=0; i<N; i++){
    for(int j=0; j<M; j++){
      if(dp[i][j] == -1) continue;
      long double sum = 0;
      for(int k=i; k<N; k++){
        sum += A[k];
        dp[k+1][j+1] = max(dp[k+1][j+1], dp[i][j] + sum/(k+1-i));
      }
    }
  }
  long double ans = 0;
  // for(int i=0; i<=N; i++){
  //   for(int j=0; j<=M; j++){
  //     cout << dp[i][j] << " \n"[j==M];
  //   }
  // }
  for(int i=1; i<=M; i++){
    ans = max(ans, dp[N][i]);
  }
  cout << fixed << setprecision(10) << ans << endl;
  return 0;
}
accuracy: 1
time_ms: 60
memory_kb: 7048
final_rank: 14