#include<bits/stdc++.h>
using namespace std;
#define sz(x) (int)(x).size()
#define all(x) x.begin(), x.end()
#define rep(i,a,b) for(int i=a;i<(b);++i)

template <class T> int sign(T x) { return (x > 0) - (x < 0); }
template<class T>
struct Point {
    typedef Point P;
    T x, y;
    explicit Point(T x = 0, T y = 0): x(x), y(y) {}
    bool operator<(P p) const { return tie(x,y) < tie(p.x,p.y); }
    bool operator==(P p) const { return tie(x,y)==tie(p.x,p.y); }
    P operator+(P p) const { return P(x+p.x, y+p.y); }
    P operator-(P p) const { return P(x-p.x, y-p.y); }
    P operator*(T d) const { return P(x*d, y*d); }
    P operator/(T d) const { return P(x/d, y/d); }
    T dot(P p) const { return P(x*p.x + y*p.y); }
    T cross(P p)const {return x*p.y - y*p.x;}
    T cross(P a, P b)const {return (a-*this).cross(b-*this);}
    T dist2() const{return x*x + y*y;}
    double dist() const {return sqrt((double)dist2());}
    //...
    P perp() const{return P(-y, x);}
    //...

    friend ostream& operator<< (ostream& os, P p) {
        return os << "(" << p.x << "," << p.y << ")";
    }
};
typedef Point<double>P;
double ccRadius(const P& A, const P& B, const P& C) {
    return (B-A) .dist() * (C-B).dist() * (A-C).dist()/
    abs((B-A).cross(C-A))/2;
}
P ccCenter(const P&A, const P&B, const P& C) {
    P b = C-A, c = B-A;
    return A + (b*c.dist2() - c*b.dist2()).perp()/b.cross(c)/2;
}

void justDoIt();

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    justDoIt();
    return 0;
}

const long long BASE = 233811181;
const long long MOD = (1LL << 31) - 1;

int n,k;
pair<double,int> monge(int lambda, vector<vector<double>>& cost){
    vector<pair<double,int>> dp(n+1);
    dp[0]=make_pair(0.0,0);
    for(int i=1;i<=n;i++){
        dp[i]=make_pair(cost[1][i]+lambda,1);
        for(int j=1;j<i;j++){
            dp[i] = min(dp[i], make_pair(dp[j].first + cost[j+1][i] + lambda, dp[j].second+1) );
        }
    }
    return dp[n];
}

void dnc(int l, int r, int low, int high, vector<double>& curDp, vector<double>& nxtDp, vector<vector<double>>& cost) {
    if (l > r) {
        return;
    }
    int m = (l + r) / 2;
    int opt = -1;
    for (int i = low; i <= min(high, m); i++) {
        if (nxtDp[m] > curDp[i - 1] + cost[i][m]) {
            nxtDp[m] = curDp[i - 1] + cost[i][m];
            opt = i;
        }
    }
    dnc(l, m - 1, low, opt, curDp, nxtDp, cost);
    dnc(m + 1, r, opt, high, curDp, nxtDp, cost);
}

void justDoIt() {
    cin >> n >> k;
    vector<long long> x(n + 1);
    vector<long long> y(n + 1);
    cin >> x[1];
    for (int i = 1; i <= n; i++) {
        if (i > 1) {
            x[i] = (y[i - 1] * BASE + 1) % MOD;
        }
        y[i] = (x[i] * BASE + 1) % MOD;
    }
    vector<P> ps(n);
    for (int i = 0; i < n; i++) {
        ps[i] = Point((double)x[i + 1], (double)y[i + 1]);
    }
    vector<vector<double>> cost(n+1, vector<double>(n+1, 0));
    for (int l = 0; l < n; l++) {
        P o = ps[l];
        double r = 0, eps = 1+1e-8;
        vector<double> res;
        rep(i,l,sz(ps)) { if((o-ps[i]).dist() > r * eps){
            o = ps[i], r=0;
            rep(j,l,i)if((o-ps[j]).dist() > r*eps){
                o = (ps[i]+ps[j])/2;
                r = (o-ps[i]).dist();
                rep(k,l,j) if((o-ps[k]).dist()>r*eps){
                    o = ccCenter(ps[i], ps[j], ps[k]);
                    r = (o-ps[i]).dist();
                }
            }
        }
        cost[l+1][i+1] = r;
        }
    }
    cout << fixed << setprecision(10);

/*    double lo=0,hi=1e15,mid;
    //monge: returns (cost, no. of times lambda was used)
    while(hi-lo > (1e-10)){
        mid = (lo+hi)/2;
        if(monge(mid,cost).first<k)hi=mid;
        else lo=mid;
    }
    pair<double,int> ans = monge(lo,cost);
    cout<<ans.first-(ans.second*lo)<<'\n';*/
/*    for (int a = 1; a <= n; a++) {
        for (int b = a; b <= n; b++) {
            for (int c = b; c <= n; c++) {
                for (int d = c; d <= n; d++) {
                    double c1 = cost[a][d] + cost[b][c];
                    double c2 = cost[a][c] + cost[b][d];
                    if (c1 > c2) {
                        cout << "NOPE " << c1 << " " << c2 << endl;
                        return;
                    }
                }
            }
        }
    }*/
/*    vector<double> curDp(n + 1);
    for (int i = 1; i <= n; i++) {
        curDp[i] = cost[1][i];
    }
    double res = curDp[n];
    for (int iter = 1; iter < k; iter++) {
        vector<double> nxtDp(n + 1, 1e30);
        nxtDp[0] = 0;
        dnc(1, n, 1, n, curDp, nxtDp, cost);
        curDp.swap(nxtDp);
        res = min(res, curDp[n]);
    }
    cout << res << endl;*/
    //dp[i][j] = i groups, first j
    vector<vector<int>> good(n + 1);
    for (int r = 1; r <= n; r++) {
        for (int l = 1; l <= r; l++) {
            if (l == 1 || cost[l - 1][r] > cost[l][r]) {
                good[r].push_back(l);
            }
        }
    }
    double res = 1e30;
        vector<vector<double>> dp(k + 1, vector<double>(n + 1, 1e30));
        dp[0][0] = 0;
        for(int j=1;j<=n;j++)dp[0][j]=1e30;
        for (int i = 1; i <= k; i++){
            dp[i][0]=0;
            for(int j=1;j<=n;j++){
                dp[i][j]=1e30;
                for (auto x: good[j]) {
                    dp[i][j] = min(dp[i][j], dp[i-1][x-1] + cost[x][j]);
                }
            }
            res = min(res, dp[i][n]);
        }
    cout << res;
}