#include <bits/stdc++.h>

using namespace std;
typedef long long ll;
typedef pair<int, int> pii;

const int N = 3005;
const int INF = 1e9;

struct Edge {
    int u, v, w;
    void scan() { scanf("%d%d%d", &u, &v, &w); }
};

struct DisjointSet {
    int fa[N], n;
    void Init(int n) {
        this->n = n;
        for (int i = 1; i <= n; i++) fa[i] = -1;
    }
    int FindFa(int u) {
        return (fa[u] < 0) ? u : (fa[u] = FindFa(fa[u]));
    }
    bool Merge(int u, int v) {
        u = FindFa(u), v = FindFa(v);
        if (u == v) return true;
        if (fa[u] + fa[v] == -n) return false;
        fa[u] += fa[v];
        fa[v] = u;
        return true;
    }
} ds;

bool solve() {
    int n, m;
    if (scanf("%d%d", &n, &m) != 2) return false;
    vector<Edge> edges(m);
    for (auto& edge : edges) edge.scan();

    int t = n * (n - 1);
    t = max(t, 10);
    t = min(t, 3000);

    int ans = INF;
    int unchange = 0;
    const int LIMIT = 2000;
    do {
        random_shuffle(edges.begin(), edges.end());
        ds.Init(n);

        bool flag = false;
        for (const auto& edge : edges) {
            if (!ds.Merge(edge.u, edge.v)) {
                flag = true;
                break;
            }
        }
        if (!flag) {
            ans = 0;
            break;
        }

        int tans = 0;
        for (const auto& edge : edges) {
            if (ds.FindFa(edge.u) != ds.FindFa(edge.v)) {
                tans += edge.w;
            }
        }

        if (ans <= tans) unchange++;
        else ans = tans, unchange = 0;

        // if (unchange >= 1000) break;

        // printf("tans %d, ans %d\n", tans, ans);
    } while (unchange <= LIMIT);

    printf("%d\n", ans);
    return true;
}

int main() {
    while (solve());
    return 0;
}