#include <vector>
#include <utility>
#include <cstdio>
#include <algorithm>

#define forn(i, n) for(int i = 0; i < (n); ++i)

using std::accumulate;
using std::make_pair;
using std::min;
using std::pair;
using std::vector;

typedef int cost_t;
typedef vector<cost_t> vcost_t;
typedef vector<vcost_t> vvcost_t;
typedef vvcost_t adjacency_matrix;
typedef vector<int> vint;
typedef pair<int, int> edge;
typedef vector<edge> vedge;
typedef vector<vedge> vvedge;
typedef pair<cost_t, edge> weighted_edge;
typedef vector<weighted_edge> vweighted_edge;

void initialize(const adjacency_matrix& A,
                vvedge& B,
                vcost_t& dist,
                vint& parent) {
  int n = dist.size();
  forn(i, n) {
    forn(j, n) {
      dist[i] = min(dist[i], A[i][j]);
      B[i][j] = edge(i, j);
    }
    parent[i] = i;
  }
}
weighted_edge lightest_edge(const adjacency_matrix& A,
                            const vcost_t& dist,
                            const vint& parent) {
  int idx = 0, n = dist.size();
  while (parent[idx] != idx) ++idx;
  for (int i = idx + 1; i < n; ++i) {
    if (parent[i] != i) continue;
    if (dist[i] < dist[idx]) idx = i;
  }
  cost_t weight = dist[idx];
  int target = 0;
  for (int i = 0; i < n; ++i) {
    if (parent[i] != i) continue;
    if (A[idx][i] == weight) {
      target = i;
      break;
    }
  }

  return weighted_edge(weight, edge(idx, target));
}

void contract(const weighted_edge& e,
              adjacency_matrix& A,
              vvedge& B,
              vcost_t& dist,
              vint& parent) {
  int n = dist.size(),
      u = e.second.first, // new parent
      v = e.second.second; // new child
  parent[v] = u;
  dist[u] = INFINITY;
  for (int i = 0; i < n; ++i) {
    if (parent[i] != i) continue;
    if (i == u) continue;
    if (A[v][i] < A[u][i]) {
      A[u][i] = A[v][i];
      B[u][i] = B[v][i];
    }
    A[i][u] = A[u][i];
    B[i][u] = edge(B[u][i].second, B[u][i].first);
    dist[u] = min(dist[u], A[u][i]);
  }
}

vweighted_edge kruskal_warnes(adjacency_matrix& A) {
  int n = A.size(), u, v;
  cost_t cost;
  vweighted_edge edges;
  vcost_t dist(n, INFINITY);
  vint parent(n);
  vvedge B(n, vedge(n, edge(0, 0)));

  initialize(A, B, dist, parent);

  int remaining = n - 1;
  while (remaining --> 0) {
    weighted_edge e = lightest_edge(A, dist, parent);
    cost = e.first;
    u = e.second.first;
    v = e.second.second;
    weighted_edge original_edge(cost, B[u][v]);
    edges.push_back(original_edge);
    contract(e, A, B, dist, parent);
  }

  return edges;
}

int main() {
  int n, m, u, v;
  cost_t w;
  scanf("%d %d", &n, &m);
  adjacency_matrix A(n, vcost_t(n, INFINITY));
  forn (j, m) {
    scanf("%d %d %d", &w, &u, &v);
    A[u][v] = A[v][u] = w;
  }
  vweighted_edge edges = kruskal_warnes(A);
  cost_t total_cost = accumulate(edges.begin(), edges.end(), 0, [](cost_t c, weighted_edge& e) {
    return c + e.first;
  });
  printf("Cost of a MST: %d.\n", total_cost);
}