代码：

#include <bits/stdc++.h>
#define ll long long
#define INF 0x3f3f3f3f
using namespace std;
struct Edge {
    int x, y, w;
    bool used;
    friend bool operator < (Edge a, Edge b) {
        return a.w < b.w;
    }
}edge[300010];
int n, m;
int p[100010];
int h[300010], e[300010], w[300010], ne[300010], idx;
int deep[100010], d1[100010][20], d2[100010][20], fa[100010][20];
int q[100010];
void add(int x, int y, int z) {
    ne[idx] = h[x];
    e[idx] = y;
    w[idx] = z;
    h[x] = idx++;
}
int find(int x) {
    if (p[x] != x) x = find(p[x]);
    return p[x];
}
ll kruskal() {
    sort(edge, edge + m);
    for (int i = 1; i <= n; ++i) p[i] = i;
    ll sum = 0;
    for (int i = 0; i < m; ++i) {
        int a = find(edge[i].x), b = find(edge[i].y), w = edge[i].w;
        if (a != b) {
            p[a] = b;
            sum += w;
            edge[i].used = 1;
        }
    }
    return sum;
}
void build() {
    memset(h, -1, sizeof h);
    for (int i = 0; i < m; ++i)
        if (edge[i].used) {
            int a = edge[i].x, b = edge[i].y, w = edge[i].w;
            add(a, b, w);
            add(b, a, w);
        }
}
void bfs() {
    memset(deep, 0x3f, sizeof deep);
    deep[0] = 0, deep[1] = 1;
    q[0] = 1;
    int head = 0, tail = 0;
    while (head <= tail) {
        int cur = q[head ++];
        for (int i = h[cur]; i != -1; i = ne[i]) {
            int j = e[i];
            if (deep[j] > deep[cur] + 1) {
                deep[j] = deep[cur] + 1;
                q[++tail] = j;
                fa[j][0] = cur;
                d1[j][0] = w[i], d2[j][0] = -INF;
                for (int k = 1; k <= 17; ++k) {
                    int an = fa[j][k - 1];
                    fa[j][k] = fa[an][k - 1];
                    int dis[4] = {d1[j][k - 1], d2[j][k - 1], d1[an][k - 1], d2[an][k - 1]};
                    d1[j][k] = d2[j][k] = -INF;
                    for (int u = 0; u < 4; ++u) {
                        int d = dis[u];
                        if (d > d1[j][k]) d2[j][k] = d1[j][k], d1[j][k] = d;
                        else if (d != d1[j][k] && d > d2[j][k]) d2[j][k] = d;
                    }
                }
            }
        }
    }
}
int LCA(int x, int y, int w) {
    static int dis[200010];
    int cnt = 0;
	if (deep[x] < deep[y]) swap(x, y);
	for (int i = 17; i >= 0; --i)
		if (deep[fa[x][i]] >= deep[y]) {
		    dis[cnt ++] = d1[x][i];
		    dis[cnt ++] = d2[x][i];
		    x = fa[x][i];
		}
	if (x != y) {
    	for (int i = 17; i >= 0; --i)
    		if (fa[x][i] != fa[y][i]) {
    			dis[cnt ++] = d1[x][i];
    			dis[cnt ++] = d2[x][i];
    			dis[cnt ++] = d1[y][i];
    			dis[cnt ++] = d2[y][i];
    			x = fa[x][i];
    			y = fa[y][i];
    		}
    	dis[cnt ++] = d1[x][0];
    	dis[cnt ++] = d1[y][0];
	}
	int dist1 = -INF, dist2 = -INF;
	for (int i = 0; i < cnt; ++i) {
	    if (dis[i] > dist1) dist2 = dist1, dist1 = dis[i];
	    else if (dis[i] != dist1 && dis[i] > dist2) dist2 = dis[i];
	}
	if (w > dist1) return w - dist1;
	if (w > dist2) return w - dist2;
	return INF;
}
int main() {
    cin >> n >> m;
    for (int i = 0; i < m; ++i) {
        int a, b, c;
        cin >> a >> b >> c;
        edge[i] = {a, b, c};
    }
    ll sum = kruskal();
    build();
    bfs();
    ll ans = 1e18;
    for (int i = 0; i < m; ++i)
        if (!edge[i].used) {
            int a = edge[i].x, b = edge[i].y, w = edge[i].w;
            ans = min(ans, sum + LCA(a, b, w));
        }
    cout << ans;
    return 0;
}