#include <iostream>
#include <vector>
#include <array>
#include <set>
#include <map>
#include <algorithm>
#include <cassert>
using namespace std;
using ll = long long;
using a3 = array<ll, 3>;
using pii = pair<ll, ll>;
const ll mn = 2e5+5;
vector<a3> edge;

struct DSU {
	vector<ll> p;
	DSU(ll n): p(n, -1) {}
	ll find(ll a) {
		return p[a] < 0 ? a : (p[a] = find(p[a]));
	}
	bool same(ll a, ll b) {
		return find(a) == find(b);
	}
	void merge(ll a, ll b) {
		a = find(a);
		b = find(b);
		if (p[a] > p[b]) swap(a,b);
		p[a] += p[b];
		p[b] = a;
	}
};

vector<pair<ll, ll>> child[mn];

const int height = 25;

ll best[mn][height], par[mn][height], dep[mn];

void dfs(ll i, ll p=0) {
	for (auto [j, cost] : child[i]) {
		if (j == p) continue;
		dep[j] = dep[i]+1;
		best[j][0] = cost;
		par[j][0] = i;
		dfs(j, i);
	}
}
ll n, m;
ll bestOnPath(ll i, ll j) {
	ll w = 0;
	if (dep[i] > dep[j]) swap(i,j);
	while (dep[i] < dep[j]) {
		ll dif = dep[i]-dep[j];
		if (j == 0) exit(1);
		w = max(w, best[j][__builtin_ctz(dif)]);
		j = par[j][__builtin_ctz(dif)];
	}
	ll x = height-1;
	while (x >= 0) {
		if (par[i][x] != par[j][x]) {
			w = max(w, best[i][x]);
			i = par[i][x];

			w = max(w, best[j][x]);
			j = par[j][x];
		}
		x--;
	}
	if (i != j) {
		x = 0;
		w = max(w, best[i][x]);
		i = par[i][x];

		w = max(w, best[j][x]);
		j = par[j][x];
	}
	assert(i == j);
	return w;
}

int main() {
	 cin >> n >> m;
	for (ll i = 0; i < m; i++) {
		ll u, v, w; cin >> u >> v >> w;
		edge.push_back({w, u, v});
	}
	DSU mst(n+1), mst2(n+1);
	sort(edge.begin(), edge.end());
	ll cnt = 0;
	map<pii, ll> vals;
	for (auto [w, i, j] : edge) {
		if (!mst.same(i, j)) {
			mst.merge(i, j);
			vals[{i, j}] = w;
		}
		else if (!mst2.same(i, j)) {
			mst2.merge(i, j);
			child[i].push_back({ j, w });
			child[j].push_back({ i, w });
			cnt++;
		}
	}
	if (cnt != n-1) {
		assert(cnt < n-1);
		cout << -1 << endl;
	}
	else {
		dfs(1, 0);
		par[1][0] = 1;
		for (ll i = 0; i < height-1; i++) {
			for (ll j = 1; j <= n; j++) {
				best[j][i+1] = max(best[j][i], best[par[j][i]][i]);
				par[j][i+1] = par[par[j][i]][i];
				if (j > 1) assert(par[j][i] != 0);
			}
		}
		ll out = 0;
		for (auto [ed, w] : vals) {
			ll cost = bestOnPath(ed.first, ed.second) - w+1;
			out += cost;
		}
		cout << out << endl;
	}
}