/**
 * P2872 [USACO07DEC] Building Roads S
 */
#include <bits/stdc++.h>
#include <numeric> // for std::iota

using namespace std;

// 坐标结构体
struct Point {
    int x, y;
};

// 距离计算函数
double get_dist(const Point& a, const Point& b) {
    // 使用 hypot 函数可以直接求 sqrt(dx^2 + dy^2)，防止中间过程溢出且写起来简单
    // 或者手动写: sqrt(pow(a.x - b.x, 2) + pow(a.y - b.y, 2))
    return std::hypot(a.x - b.x, a.y - b.y);
}

// 这里的 Edge 需要适配 double 类型的权重
struct Edge {
    int u, v;
    double w; // 权值改为 double
    bool operator<(const Edge& other) const {
        return w < other.w;
    }
};

struct KruskalAlgorithm {
    struct DSU {
        std::vector<int> fa;
        void init(int n) {
            fa.resize(n + 1);
            std::iota(fa.begin(), fa.end(), 0);
        }
        int find(int x) {
            return x == fa[x] ? x : fa[x] = find(fa[x]);
        }
        bool merge(int x, int y) {
            int fx = find(x), fy = find(y);
            if (fx == fy) return false;
            fa[fx] = fy;
            return true;
        }
    } dsu;

    int n;
    std::vector<Edge> edges;

    void init(int _n) {
        n = _n;
        edges.clear();
        dsu.init(n);
    }

    void add_edge(int u, int v, double w) {
        edges.push_back({u, v, w});
    }

    // 预先合并已经存在的边（相当于权值为0）
    void merge_existing(int u, int v) {
        dsu.merge(u, v);
    }

    // 返回最小生成树需要的额外长度
    double solve() {
        std::sort(edges.begin(), edges.end());
        
        double ans = 0;
        int cnt = 0; // 这里的 cnt 不太好直接用来判断退出，因为有一些边是预先合并的
                     // 但我们可以依靠遍历完所有边或者增加一个连通块计数器来优化
                     // 这里为了代码简单，直接遍历所有边即可

        for (const auto& e : edges) {
            if (dsu.merge(e.u, e.v)) {
                ans += e.w;
            }
        }
        
        return ans;
    }
} kruskal;

Point points[1005]; // 存储点坐标

int main() {
    // 优化 IO
    ios::sync_with_stdio(false);
    cin.tie(0);

    int n, m;
    cin >> n >> m;

    kruskal.init(n);

    // 1. 读入坐标
    for (int i = 1; i <= n; i++) {
        cin >> points[i].x >> points[i].y;
    }

    // 2. 处理已有的路 (直接在并查集中合并，不需要加入边列表参与排序)
    for (int i = 1; i <= m; i++) {
        int u, v;
        cin >> u >> v;
        kruskal.merge_existing(u, v);
    }

    // 3. 生成所有可能的边 (完全图)
    for (int i = 1; i <= n; i++) {
        for (int j = i + 1; j <= n; j++) {
            double w = get_dist(points[i], points[j]);
            kruskal.add_edge(i, j, w);
        }
    }

    // 4. 计算结果
    double result = kruskal.solve();

    // 5. 输出，保留两位小数
    cout << fixed << setprecision(2) << result << endl;

    return 0;
}