// #define _GLIBCXX_DEBUG // for STL debug (optional)
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <string>
#include <cstring>
#include <deque>
#include <list>
#include <queue>
#include <stack>
#include <vector>
#include <utility>
#include <algorithm>
#include <map>
#include <set>
#include <complex>
#include <cmath>
#include <limits>
#include <cfloat>
#include <climits>
#include <ctime>
#include <cassert>
#include <numeric>
#include <fstream>
#include <functional>
#include <bitset>
using namespace std;
using ll = long long int;
using int64 = long long int;
 
template<typename T> void chmax(T &a, T b) {a = max(a, b);}
template<typename T> void chmin(T &a, T b) {a = min(a, b);}
template<typename T> void chadd(T &a, T b) {a = a + b;}
 
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
const int INF = 1LL << 29;
const ll LONGINF = 1LL << 60;
const ll MOD = 1000000007LL;

/***** 基本的準備 *****/

// xy平面上の点(ベクトル)を表現するには、complex型を利用するとよい
typedef complex<double> P;

// 辺の表現 (座標を2つ pair でもつ)
typedef pair<P, P> L;

// 円の表現 (座標 P と 半径 d で表現する)
typedef pair<P, double> C;

// 成分を取り出すのを簡単にする
#define X real()
#define Y imag()

// 誤差(epsilon)の定義
#define EPS (1e-10)

// 2つの要素が等しいかどうか
#define EQ(a,b) (abs((a) - (b)) < EPS)

// 2つのベクトルが等しいかどうか
#define EQV(a,b) ( EQ((a).X, (b).X) && EQ((a).Y, (b).Y) )

// m は n より大きい(以上)かどうか
#define LE(n, m) ((n) < (m) + EPS)
#define LEQ(n, m) ((n) <= (m) + EPS)

// m は n より小さい(以下)かどうか
#define GE(n, m) ((n) + EPS > (m))
#define GEQ(n, m) ((n) + EPS >= (m))

// 2つのベクトルの内積を求める
double dot(P a, P b) {
    return (a.X * b.X + a.Y * b.Y);
}

// 2つのベクトルの外積を求める
double cross(P a, P b) {
    return (a.X * b.Y - a.Y * b.X);
}

// ccw (c が直線(線分) ab に対してどのような位置関係か？)
// Verified: AOJ CGL_1_C: Counter-Clockwise
// +1 ... a → b で半時計方向に折れて b → c (COUNTER_CLOCKWISE)
// -1 ... a → b で時計方向に折れて b → c (CLOCKWISE)
// +2 ... c, a, b がこの順で同一直線状にある場合 (ONLINE_BACK)
// -2 ... a, b, c がこの順で同一直線状にある場合 ( or a == b ) (ONLINE_FRONT)
//  0 ... c が線分 ab 上にある場合 (点 a, b 上を含む) (ON_SEGMENT)
int ccw(P a, P b, P c) {
    b -= a; c -= a;
    if( cross(b,c) > EPS ) return +1;
    if( cross(b,c) < -EPS ) return -1;
    if( dot(b,c) < 0 ) return +2;
    if( norm(b) < norm(c) ) return -2;
    return 0;
}

// 点 a1, a2 を端点とする線分と点 b との距離
double dist_sp(P a1, P a2, P b) {
    if( dot(a2-a1, b-a1) < EPS ) return abs(b - a1);
    if( dot(a1-a2, b-a2) < EPS ) return abs(b - a2);
    return abs( cross(a2-a1, b-a1) ) / abs(a2 - a1);
}

int main() {
    int N, M; cin >> N >> M;
    vector<P> points(N+1);
    for(int i=0; i<N+1; i++) {
        int x, y; cin >> x >> y;
        points[i] = P(x, y);
    }

    vector<bool> selected(N+1, false);
    selected[0] = true;
    vector<double> dist(N+1, INF), pdist(N+1, INF), best(N+1, -1);
    for(int i=1; i<=N; i++) {
        double x = points[0].real() - points[i].real();
        double y = points[0].imag() - points[i].imag();
        dist[i] = sqrt(x*x + y*y);
        pdist[i] = dist[i];
        best[i] = 0;
    }

    double ans = 0;
    for(int i=0; i<M; i++) {
        double min_val = INF; int argmin = -1;
        for(int k=1; k<=N; k++) {
            if(selected[k]) continue;
            // fprintf(stderr, "k = %d, dist = %.12f\n", k, dist[k]);
            if(min_val > dist[k]) {
                min_val = dist[k];
                argmin = k;
            }
        }

        ans += pdist[argmin];
        selected[argmin] = true;

        // argmin と best[argmin] で辺ができる
        // 辺との距離
        int u = argmin, v = best[argmin];
        // fprintf(stderr, "u = %d, v = %d\n", u, v);
        for(int k=0; k<=N; k++) {
            double cost = dist_sp(points[u], points[v], points[k]);
            if(dist[k] > cost) {
                dist[k] = cost;
            }
        }

        // 頂点との距離
        // 誰とつなぐのが最も近いかも更新
        for(int k=0; k<=N; k++) {
            double x = points[argmin].real() - points[k].real();
            double y = points[argmin].imag() - points[k].imag();

            double cost = sqrt(x*x + y*y);
            dist[k] = min(dist[k], cost);

            if(pdist[k] > cost) {
                pdist[k] = cost;
                best[k] = argmin;
            }
        }
    }
    printf("%.12f\n", ans);
    return 0;
}



Measured memory_bytes: 3404