#include<bits/stdc++.h>

using namespace std;

#define all(x) (x).begin(), (x).end()
#define sz(x) (int)(x).size()

#define X first
#define Y second

using ll = long long;
using pii = pair<int, int>;
using pll = pair<long long, long long>;
using ld = long double;
using pld = pair<ld, ld>;

const int N = 3e5 + 5;
const int inf = 1e9;

template<typename T>
pair<T, T> operator-(pair<T, T> A, pair<T, T> B) {
    return make_pair(A.X - B.X, A.Y - B.Y);
}

template<typename T>
pair<T, T> operator+(pair<T, T> A, pair<T, T> B) {
    return make_pair(A.X + B.X, A.Y + B.Y);
}

template<typename T>
pair<T, T> operator*(pair<T, T> A, T x) {
    return make_pair(A.X * x, A.Y * x);
}

template<typename T>
tuple<T, T, T> makeLine(pair<T, T> A, pair<T, T> B) {
    T a = A.X, b = A.Y, c = -(a * B.X + b * B.Y);
    return make_tuple(a, b, c);
}

template<typename T>
tuple<T, T, T> medianPerpendicular(pair<T, T> A, pair<T, T> B) {
    pair<T, T> c = B - A;
    c = c * ld(0.5);
    return makeLine(c, c + A);
}

template<typename T>
pair<T, T> cross(tuple<T, T, T> A, tuple<T, T, T> B) {
    auto [a1, b1, c1] = A;
    auto [a2, b2, c2] = B;
    return make_pair((c2 * b1 - c1 * b2) / (a1 * b2 - a2 * b1), (c2 * a1 - c1 * a2) / (b1 * a2 - b2 * a1));
}

struct Circle {
    pld c;
    ld r;

    Circle() = default;

    Circle(pld p1, pld p2) {
        c = p2 - p1;
        c = c * ld(0.5);
        r = sqrtl(c.X * c.X + c.Y * c.Y);
        c = c + p1;
    }

    Circle(pld p1, pld p2, pld p3) {
        c = cross(medianPerpendicular(p1, p2), medianPerpendicular(p2, p3));
        auto d = p1 - c;
        r = sqrtl(d.X * d.X + d.Y * d.Y);
    }

    bool in(pll x) {
        return (c.X - x.X) * (c.X - x.X) + (c.Y - x.Y) * (c.Y - x.Y) <= r * r;
    }
};

bool Inside(pld O, Circle C) {
    auto d = C.c - O;
    return sqrtl(d.X * d.X + d.Y * d.Y) <= C.r;
}

Circle solve2(vector<pll> &a, int i, int j) {
    Circle C(a[i], a[j]);
    for (int k = 0; k < j; k++) {
        if (!Inside(a[k], C))C = Circle(a[i], a[j], a[k]);
    }
    return C;
}

Circle solve1(vector<pll> &a, int i) {
    Circle C(a[0], a[i]);
    for (int j = 1; j < i; j++) {
        if (!Inside(a[j], C))C = solve2(a, i, j);
    }
    return C;
}

Circle solve0(vector<pll> a) {
    Circle C(a[0], a[1]);
    for (int i = 2; i < a.size(); i++) {
        if (!Inside(a[i], C))C = solve1(a, i);
    }
    return C;
}

ll f(ll x) {
    ll mod = (1ll << 31) - 1;
    return (x * 233811181ll + 1) % mod;
}

void solve() {
    cout << fixed << setprecision(10);

    int n, k;
    cin >> n >> k;
    vector<pll> a(n);
    cin >> a[0].X;
    a[0].Y = f(a[0].X);
    for (int i = 1; i < n; ++i) {
        a[i].X = f(a[i - 1].Y);
        a[i].Y = f(a[i].X);
    }
    vector<vector<pair<ld, int>>> move(n);
    for (int i = 0; i < n; ++i) {
        Circle cr;
        cr.r = 0;
        cr.c = a[i];
        move[i].emplace_back(cr.r, i);
        for (int j = i - 1; j >= 0; --j) {
            if (cr.in(a[j])) {
                move[i].back().second = j;
            } else {
                cr = solve0(vector(a.begin() + j, a.begin() + i + 1));
                move[i].emplace_back(cr.r, j);
            }
        }
    }
    vector<vector<ld>> dp(n + 1, vector<ld>(k + 1, 1e16));
    dp[0][0] = 0;
    for (int i = 0; i < n; ++i) {
        for (auto [r, j]: move[i]) {
            for (int l = 0; l < k; ++l) {
                dp[i + 1][l + 1] = min(dp[i + 1][l + 1], dp[j][l] + r);
            }
        }
    }
    cout << dp[n][k];
}

int main() {
#ifndef LOCAL
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
#else
    freopen("input.txt", "r", stdin);
#endif
    int t = 1;
//    cin >> t;
    while (t--)
        solve();
    return 0;
}