#include<bits/stdc++.h>

using namespace std;

vector<int> p, _size;
int ans;

struct Edge {
    int from, to, cost;
};

int find(int v) {
    if (p[v] == v)
        return v;
    return p[v] = find(p[v]);
}

void union_s(int a, int b, int w) {
    a = find(a);
    b = find(b);
    if (a != b) {
        ans += w;
        if (_size[a] < _size[b])
            swap(a, b);
        p[b] = a;
        _size[a] += _size[b];
    }
}


int main() {
    int n, m;
    cin >> n >> m;
    vector<Edge> es;
    _size.resize(n, 1);
    p.resize(n);
    for (int i = 0; i < n; i++)
        p[i] = i;
    for (int i = 0; i < m; i++) {
        int from, to, cost;
        cin >> from >> to >> cost;
        from--, to--;
        es.push_back({from, to, cost});
    }

    sort(es.begin(), es.end(), [](const Edge left, const Edge right) {
        return left.cost < right.cost;
    });

    for (auto e : es)
        union_s(e.from, e.to, e.cost);

    cout << ans;
}


#include <bits/stdc++.h>

using namespace std;

const double INF = 1000000000.0;

double len(double x1, double y1, double x2, double y2) {
    return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
}

int main() {
    int n;
    cin >> n;
    double ans = 0.0;
    vector<double> x(n), y(n);
    for (int i = 0; i < n; ++i) {
        cin >> x[i] >> y[i];
    }
    vector<bool> used (n);
    vector<double> min_e (n, INF);
    vector<int> sel_e (n, -1);
    min_e[0] = 0;
    for (int i = 0; i < n; ++i) {
        int v = -1;
        for (int j = 0; j < n; ++j)
            if (!used[j] && (v == -1 || min_e[v] - min_e[j] > 1e-9))
                v = j;
        used[v] = true;
//        cout << min_e[v] << ' ' << v << '\n';
        if (sel_e[v] != -1)
            ans += min_e[v];
        for (int to = 0; to < n; ++to)
            if (min_e[to] - len(x[v], y[v], x[to], y[to]) > 1e-9) {
                min_e[to] = len(x[v], y[v], x[to], y[to]);
                sel_e[to] = v;
            }
    }
    cout << fixed << setprecision(5) << ans;
    return 0;
}