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

constexpr double eps = 1e-6;

constexpr long long INF = 1e18;

struct Node {
    int val;
    int lpos, rpos;
    // init
    Node() : val(-1) {}
    Node(int p) : val(p) {}

    // update
    Node& operator+=(const Node& n) {
        val = max(val, n.val);
        return *this;
    }

    // push_up
    Node push_up(const Node& ln, const Node& rn) {
        val = max(ln.val, rn.val);
        return *this;
    }
};

struct SegmentTree {
    #define lp (p << 1)
    #define rp (p << 1 | 1)
    vector<Node> node;
    SegmentTree(int n = 0) {
        resize(n);
    }

    void resize(int n) {
        node.resize((n + 1) * 4);
    }

    void build(int l, int r, int p = 1) {
        node[p] = Node();
        node[p].lpos = l;
        node[p].rpos = r;
        node[p].val = -1;
        if (l == r) {
            return;
        }
        int mid = (l + r) >> 1;
        build(l, mid, lp);
        build(mid + 1, r, rp);
        node[p].push_up(node[lp], node[rp]);
    }

    void update(int pos, const Node& k, int p = 1) {
        if (node[p].lpos == pos && pos == node[p].rpos) {
            node[p] += k;
            return;
        }

        int mid = (node[p].lpos + node[p].rpos) >> 1;
        if (pos <= mid) {
            update(pos, k, lp);
        } else {
            update(pos, k, rp);
        }
        node[p].push_up(node[lp], node[rp]);
    }

    Node query(const int& l, const int& r, int p = 1) {
        if (l <= node[p].lpos && node[p].rpos <= r) {
            return node[p];
        }

        int mid = (node[p].lpos + node[p].rpos) >> 1;
        if (r <= mid) {
            return query(l, r, lp);
        }

        if (mid < l) {
            return query(l, r ,rp);
        }

        return Node().push_up(query(l, r, lp), query(l, r, rp));
    }
    #undef lp
    #undef rp
};

        // int sum=0;
        // vector<double>fb;
        // for(int i=1;i<=n;i++)
        // {
        //     if(sum==0)
        //     {
        //         pre[++sum]=b[i];
        //         fb.push_back(-1*b[i]);
        //         suf[sum]=1;
        //     }
        //     if(pre[sum]>b[i])
        //     {
        //         pre[++sum]=b[i];
        //         fb.push_back(-1*b[i]);
        //         suf[sum]=1;
        //     }
        //     else
        //     {
        //         int it=lower_bound(fb.begin(),fb.end(),-1*b[i])-fb.begin();
        //         pre[it+1]=b[i];
        //         fb[it]=-1*b[i];
        //         suf[it+1]++;
        //     }
        // }
        // for(int i=1;i<=sum;i++)
        // {
        //     if(pre[i]==b[n])
        //     {
        //         return suf[i]>=k;
        //     }
        // }
        // return false;

void solve() {
    i64 n, k;
    cin >> n >> k;
    vector<i64> a(n + 1);
    SegmentTree sgt(n + 1);
    for (int i = 1; i <= n; i++) {
        cin >> a[i];   
    }

    auto check = [&](double x) -> bool {
        sgt.build(0, n);
        vector<int> f(n + 1);
        vector<double> b(n + 1);
        
        for (int i = 1; i <= n; i++) {
            b[i] = a[i] - x;
            b[i] += b[i - 1];
            // cerr << b[i] << " ";
        }
        // cerr << endl;

        auto tmp = b;
        sort(tmp.begin(), tmp.end());
        for (int i = 0; i <= n; i++) {
            int pos = lower_bound(tmp.begin(), tmp.end(), b[i]) - tmp.begin();
            int val = sgt.query(0, pos).val;
            if (val != -1) {
                f[i] = val + 1;
            }

            if (i == 0 || f[i] != 0) {
                sgt.update(pos, f[i]);
            }
            // cerr << f[i] << " ";
        }
        // cerr << endl;

        return f[n] >= k;
    };

    // cerr << check(5. / 3) << endl;

    double l = 1;
    double r = *max_element(a.begin() + 1, a.end());
    double ans = 1;
    while (r - l > eps) {
        double m = (l + r) / 2;
        if (check(m)) {
            ans = max(ans, m);
            l = m;
        } else {
            r = m;
        }
    }

    cout << fixed << setprecision(15) << ans;
}

int main() {
    ios::sync_with_stdio(false);
    cout.tie(0);
    cin.tie(0);

    int T = 1;
    // cin >> T;
    for (int i = 1; i <= T; i++) {
        solve();
    }

    return 0;
}