RT, code :

#include <bits/stdc++.h>

using namespace std;
using LL = long long;
using Pii = pair<int, LL>;

const int kMaxN = 3e5 + 5, kL = 21;

struct E {
  LL u, v, w;
  bool operator<(const E &a) const {
    return w < a.w;
  }
} e[kMaxN * 3];

LL n, m, ans = 1e18, tot, cnt, p[kMaxN * 3], dep[kMaxN], f[kMaxN][kL], g[kMaxN][kL];  //  p记录路径上的值，dep记录节点深度，f求2^i级祖先，g求路径最大值
LL t[kMaxN][kL], fa[kMaxN], vis[kMaxN * 3];                                           //  t记录路径次大值，fa并查集，vis边是否在最小生成树中
vector<Pii> v[kMaxN];

int find(int x) {
  return fa[x] == x ? x : fa[x] = find(fa[x]);
}

void dfs(int u, int fa) {
  for (int i = 1; i < kL; i++) {
    f[u][i] = f[f[u][i - 1]][i - 1];
    g[u][i] = max(g[u][i - 1], g[f[u][i - 1]][i - 1]);
    LL s[4] = {g[u][i - 1], t[u][i - 1], g[f[u][i - 1]][i - 1], t[f[u][i - 1]][i - 1]};
    sort(s, s + 4);
    int sx = unique(s, s + 4) - s;
    t[u][i] = s[sx - 1];
  }
  for (Pii i : v[u]) {
    if (i.first != fa) {
      f[i.first][0] = u, g[i.first][0] = i.second, dep[i.first] = dep[u] + 1;
      dfs(i.first, u);
    }
  }
}

int LCA(int x, int y) {
  if (dep[x] < dep[y]) {
    swap(x, y);
  }
  for (int i = kL - 1; i >= 0; i--) {
    (dep[f[x][i]] >= dep[y]) && (x = f[x][i]);
  }
  if (x == y) {
    return x;
  } else {
    for (int i = kL - 1; i >= 0; i--) {
      (f[x][i] != f[y][i]) && (x = f[x][i], y = f[y][i]);
    }
    return f[x][0];
  }
}

void S(int x, int y) {
  for (int i = kL - 1; i >= 0; i--) {
    (dep[f[x][i]] >= dep[y]) && (p[++tot] = g[x][i], p[++tot] = t[x][i], x = f[x][i]);
  }
}

int main() {
  cin >> n >> m;
  for (int i = 1; i <= m; i++) {
    cin >> e[i].u >> e[i].v >> e[i].w;
  }
  sort(e + 1, e + m + 1);
  for (int i = 1; i <= n; i++) {
    fa[i] = i;
  }
  for (int i = 1; i <= m; i++) {
    if (find(e[i].u) != find(e[i].v)) {
      fa[find(e[i].u)] = find(e[i].v);
      v[e[i].u].push_back({e[i].v, e[i].w});
      v[e[i].v].push_back({e[i].u, e[i].w});
      vis[i] = 1;
      cnt += e[i].w;
    }
  }
  dfs(1, 0);
  for (int i = 1; i <= m; i++) {
    if (!vis[i] && e[i].u != e[i].v) {
      int lca = LCA(e[i].u, e[i].v);
      S(e[i].u, lca), S(e[i].v, lca);
      sort(p + 1, p + tot + 1);
      tot = unique(p + 1, p + tot + 1) - p - 1;
      if (p[tot] == e[i].w) {
        ans = min(ans, e[i].w - p[tot - 1]);
      } else {
        ans = min(ans, e[i].w - p[tot]);
      }
      tot = 0;
    }
  }
  cout << ans + cnt;
  return 0;
}