#include <bits/stdc++.h>
using namespace std;
using i64 = long long;

struct DSU {
    vector<int> f, siz;
    vector<vector<int>> pos;
    
    DSU() {}
    DSU(int n) {
        init(n);
    }
    
    void init(int n) {
        f.resize(n + 1);
        iota(f.begin(), f.end(), 0);
        siz.assign(n + 1, 1);
        pos.assign(n + 1, {});
    }
    
    int find(int x) {
        while (x != f[x]) {
            x = f[x] = f[f[x]];
        }
        return x;
    }
    
    bool same(int x, int y) {
        return find(x) == find(y);
    }
    
    bool merge(int x, int y) {
        x = find(x);
        y = find(y);
        if (x == y) {
            return false;
        }
        if (pos[x].size() < pos[y].size()) {
        	swap(pos[x], pos[y]);
        }
        for (auto idx : pos[y]) {
        	pos[x].emplace_back(idx);
        }
        siz[x] += siz[y];
        f[y] = x;
        return true;
    }
    
    int size(int x) {
        return siz[find(x)];
    }
};

void solve() {
	int n, m;
	cin >> n >> m;
	vector<tuple<int, int, int>> edge;
	vector<int> vis(m);
	vector<int> y;
	for (int i = 0; i < m; i++) {
		int a, b, c;
		cin >> a >> b >> c;
		if (a > b) swap(a, b);
		edge.emplace_back(c, a, b);
		y.emplace_back(c);
	}
	sort(y.begin(), y.end());
	y.resize(unique(y.begin(), y.end()) - y.begin());
	for (auto &[w, u, v] : edge) {
		w = lower_bound(y.begin(), y.end(), w) - y.begin();
	}
	sort(edge.begin(), edge.end());

	DSU dsu(n);
	for (int i = 0; i < m; i++) {
		auto [w, u, v] = edge[i];
		if (dsu.same(u, v)) {
			continue;
		}
		vis[i] = 1;
		dsu.merge(u, v);
	}

	dsu.init(n);
	i64 ans = 0;
	for (int i = 0; i < m; i++) {
		if (vis[i]) {
			auto [w, u, v] = edge[i];
			ans -= y[w];
		}
	}

	for (int i = 0; i < m; i++) {
		auto [w, u, v] = edge[i];
		u = dsu.find(u);
		v = dsu.find(v);
		if (vis[i]) {
			dsu.pos[u].emplace_back(i);
			continue;
		}
		if (dsu.same(u, v)) continue;
		dsu.merge(u, v);

		vector<int> nex;
		for (auto idx : dsu.pos[u]) {
			auto [a, u, v] = edge[idx];
			if (dsu.same(u, v)) {
				ans += y[w] + 1;
			} else {
				nex.emplace_back(idx);
			}
		}
		swap(dsu.pos[u], nex);
	}
	if (dsu.size(1) != n) {
		cout << "-1\n";
		return;
	}
	cout << ans << "\n";
}

signed main() {
	ios::sync_with_stdio(false);
	cin.tie(nullptr);
	cout.tie(nullptr);

	int t = 1;
	// cin >> t;

	while (t--) {
		solve();
	}

	return 0;
}