#include <iostream>
#include <vector>
#include <cmath>
#include <iomanip>
#include <limits>

using namespace std;

const double INF = 1e18;

int main() {
    int N, M;
    cin >> N >> M;

    vector<pair<int, int>> coords(N + 1);
    for (int i = 1; i <= N; ++i) {
        cin >> coords[i].first >> coords[i].second;
    }

    // Danh sách kề (adjacency list) cho các cạnh đã cho
    vector<vector<int>> adj(N + 1);
    for (int i = 0; i < M; ++i) {
        int u, v;
        cin >> u >> v;
        adj[u].push_back(v);
        adj[v].push_back(u);
    }

    vector<double> minDist(N + 1, INF);
    vector<bool> visited(N + 1, false);

    // Khởi tạo Prim từ node 1, khoảng cách về 0
    minDist[1] = 0.0;
    double totalLength = 0;
    int nodesAdded = 0;

    // Hàng đợi ưu tiên lưu {khoang_cach, node}
    // Sử dụng min-heap
    priority_queue<pair<double, int>, vector<pair<double, int>>, greater<pair<double, int>>> pq;
    pq.push({0.0, 1});

    while (!pq.empty()) {
        double d = pq.top().first;
        int u = pq.top().second;
        pq.pop();

        if (visited[u]) continue;

        visited[u] = true;
        totalLength += d;
        nodesAdded++;

        // Cập nhật cho các node kề qua đường cũ (độ dài 0)
        for (int v : adj[u]) {
            if (!visited[v] && minDist[v] > 0) {
                minDist[v] = 0;
                pq.push({0.0, v});
            }
        }

        // Cập nhật cho các node còn lại qua đường mới (tính khoảng cách)
        for (int v = 1; v <= N; ++v) {
            if (v == u || visited[v]) continue;

            double dist = sqrt(pow(coords[u].first - coords[v].first, 2) + 
                               pow(coords[u].second - coords[v].second, 2));

            if (dist < minDist[v]) {
                minDist[v] = dist;
                pq.push({dist, v});
            }
        }
    }

    cout << fixed << setprecision(2) << totalLength << endl;

    return 0;
}

#include <iostream>
#include <vector>
#include <cmath>
#include <algorithm>
#include <iomanip>

using namespace std;

struct Edge {
    int u, v;
    double w;
    bool isOld;

    bool operator<(const Edge& other) const {
        return w < other.w;
    }
};

vector<int> parent;

int find_set(int v) {
    if (v == parent[v]) return v;
    return parent[v] = find_set(parent[v]);
}

bool union_sets(int a, int b) {
    a = find_set(a);
    b = find_set(b);
    if (a != b) {
        parent[b] = a;
        return true;
    }
    return false;
}

int main() {
    int N, M;
    cin >> N >> M;

    vector<pair<int, int>> coords(N + 1);
    for (int i = 1; i <= N; ++i) {
        cin >> coords[i].first >> coords[i].second;
    }

    vector<Edge> edges;
    // Đọc các đường cũ
    for (int i = 0; i < M; ++i) {
        int u, v;
        cin >> u >> v;
        edges.push_back({u, v, 0.0, true});
    }

    // Tạo các cạnh mới (Full graph)
    for (int i = 1; i <= N; ++i) {
        for (int j = i + 1; j <= N; ++j) {
            double dist = sqrt(pow(coords[i].first - coords[j].first, 2) + 
                               pow(coords[i].second - coords[j].second, 2));
            edges.push_back({i, j, dist, false});
        }
    }

    // Sắp xếp các cạnh theo trọng số tăng dần
    sort(edges.begin(), edges.end());

    // Khởi tạo DSU
    parent.resize(N + 1);
    for (int i = 1; i <= N; ++i) parent[i] = i;

    double totalLength = 0;
    int edgesCount = 0;

    for (const auto& edge : edges) {
        if (union_sets(edge.u, edge.v)) {
            // Chỉ cộng độ dài nếu là đường mới (trọng số > 0)
            // Hoặc đơn giản là cộng edge.w, vì đường cũ w=0
            totalLength += edge.w;
            edgesCount++;
            if (edgesCount == N - 1) break;
        }
    }

    cout << fixed << setprecision(2) << totalLength << endl;

    return 0;
}

// Code tương tự Approach 1 nhưng tối ưu hơn việc kiểm tra visited
// Giảm thiểu việc tính toán lại khoảng cách
#include <iostream>
#include <vector>
#include <cmath>
#include <queue>
#include <iomanip>
#include <algorithm>

using namespace std;

const double INF = 1e18;

int main() {
    int N, M;
    cin >> N >> M;

    vector<pair<int, int>> coords(N + 1);
    for (int i = 1; i <= N; ++i) {
        cin >> coords[i].first >> coords[i].second;
    }

    vector<vector<int>> adj(N + 1);
    for (int i = 0; i < M; ++i) {
        int u, v;
        cin >> u >> v;
        adj[u].push_back(v);
        adj[v].push_back(u);
    }

    vector<double> minDist(N + 1, INF);
    vector<bool> visited(N + 1, false);
    vector<bool> inQueue(N + 1, false); // Đánh dấu node có trong hàng đợi chưa

    priority_queue<pair<double, int>, vector<pair<double, int>>, greater<pair<double, int>>> pq;

    // Bắt đầu từ node 1
    minDist[1] = 0;
    pq.push({0, 1});
    inQueue[1] = true;

    double totalLength = 0;
    int count = 0;

    while (!pq.empty() && count < N) {
        double d = pq.top().first;
        int u = pq.top().second;
        pq.pop();

        if (visited[u]) continue;

        visited[u] = true;
        totalLength += d;
        count++;

        // 1. Xử lý đường cũ: Duyệt kề
        for (int v : adj[u]) {
            if (!visited[v] && minDist[v] > 0) {
                minDist[v] = 0;
                pq.push({0, v});
                inQueue[v] = true;
            }
        }

        // 2. Xử lý đường mới: Cập nhật khoảng cách cho các node còn lại
        for (int v = 1; v <= N; ++v) {
            if (v == u || visited[v]) continue;

            double dist = sqrt(pow(coords[u].first - coords[v].first, 2) + 
                               pow(coords[u].second - coords[v].second, 2));

            if (dist < minDist[v]) {
                minDist[v] = dist;
                pq.push({dist, v});
                inQueue[v] = true;
            }
        }
    }

    cout << fixed << setprecision(2) << totalLength << endl;

    return 0;
}