#include <bits/stdc++.h>
#define int long long
#define fastio ios::sync_with_stdio(0), cin.tie(0);
using namespace std;

#ifdef LOCAL
#define cout cout << "\033[0;32m"
#define cerr cerr << "\033[0;32m"
#define endl "\n" << "\033[0m"
#else
#pragma GCC optimize("O3,unroll-loops")
#pragma GCC target("avx,avx2,sse,sse2,sse3,sse4,popcnt")
#define endl "\n"
#endif

#define pii pair<int,int>
#define all(x) (x).begin(), (x).end()

struct dsu_struct{
    int n;
    vector<int> p, sz;
    void init(int _n) {
        n = _n + 10;
        p.resize(n);
        sz.resize(n);
        for (int i = 0; i <= _n; ++i) {
            p[i] = i;
            sz[i] = 1;
        }
    }
    int qry(int i) {
        if (p[p[i]] == p[i]) return p[i];
        return p[i] = qry(p[i]);
    }
    bool merg(int u, int v) {
        u = qry(u);
        v = qry(v);
        if (u == v) return false;
        if (sz[u] < sz[v]) swap(u, v);
        // let sz[v] < sz[u]
        sz[u] += sz[v];
        p[v] = u;
        return true;
    }
};

const int MAX_N = 5e5+10;
const int INF = 2e18;
const int mxlg = 18;
vector<pair<int, pii>> EV;
vector<pii> E[MAX_N]; // {to, w}
bool in_tree[MAX_N]; // in the first unique tree
int dep[MAX_N], jmp[MAX_N][mxlg], jval[MAX_N][mxlg];

void dfs(int v, int p) {
    for (auto &i:E[v]) {
        if (i.first == p) continue;
        jmp[i.first][0] = v;
        jval[i.first][0] = i.second;
        dep[i.first] = dep[v] + 1;
        dfs(i.first, v);
    }
}

int lca_qry(int u, int v) {
    if (dep[u] > dep[v]) swap(u, v);
    // let dep[v] > dep[u]
    int diff = dep[v] - dep[u], ret = 0;
    for (int j = mxlg - 1; j >= 0; --j) {
        if (diff & (1 << j)) {
            ret = max(ret, jval[v][j]);
            v = jmp[v][j];
        }
    }
    if (u == v) return ret;
    for (int j = mxlg - 1; j >= 0; --j) {
        if (jmp[v][j] != jmp[u][j]) {
            v = jmp[v][j];
            u = jmp[u][j];
            ret = max(ret, max(jval[v][j], jval[u][j]));
        }
    }
    return max(ret, max(jval[v][0], jval[u][0]));
}

void solve1(){
    int n, m; cin >> n >> m;
    EV.resize(m);
    for (int i = 0; i < m; ++i) {
        int u, v, w; cin >> u >> v >> w;
        EV[i] = {w, {u, v}};
    }
    sort(all(EV));
    dsu_struct dsu;
    dsu.init(n);
    for (int i = 0; i < m; ++i) {
        in_tree[i] = dsu.merg(EV[i].second.first, EV[i].second.second);
    }
    dsu.init(n);
    int comp = n;
    for (int i = 0; i < m; ++i) {
        if (!in_tree[i]) {
            comp -= dsu.merg(EV[i].second.first, EV[i].second.second);
        }
    }
    if (comp != 1) {
        cout << "-1" << endl;
        return;
    }
    dsu.init(n);
    for (int i = 0; i < m; ++i) {
        if (!in_tree[i]) {
            int u = EV[i].second.first;
            int v = EV[i].second.second;
            if (dsu.merg(u, v)) {
                int w = EV[i].first;
                E[u].push_back({v, w});
                E[v].push_back({u, w});
//                cout << u << ' ' << v << ", w = " << w << endl;
            }
        }
    }
    jmp[1][0] = 1;
    dfs(1, -1);
    for (int j = 1; j < mxlg; ++j) {
        for (int i = 1; i <= n; ++i) {
            jval[i][j] = max(jval[i][j-1], jval[ (jmp[i][j-1]) ][j-1]);
            jmp[i][j] = jmp[ (jval[i][j-1]) ][j-1];
        }
    }
    int ans = 0;
    for (int i = 0; i < m; ++i) {
        if (in_tree[i]) {
            int u = EV[i].second.first;
            int v = EV[i].second.second;
            int w = EV[i].first;
            ans += lca_qry(u, v) + 1 - w;
        }
    }
//    cout << jmp[4][0] << ' ' << jmp[2][0] << endl;
//    cout << jval[4][0] << ' ' << jval[2][0] << endl;
//    cout << jval[4][1] << endl;
    cout << ans << endl;
}

signed main(){
//    freopen("pM.in", "r", stdin);
    fastio;

    int t = 1;
    while (t--){
        solve1();
    }

    return 0;
}