#include <bits/stdc++.h>
using namespace std;
using ll = long long;

vector<vector<pair<ll, ll>>> graph;
vector<bool> visited;
vector<ll> parent, depth, cycle_id;
vector<ll> cycle_sum;
vector<vector<ll>> cycle_edges;
ll total_sum = 0;

void dfs(ll u, ll p = -1, ll d = 0) {
    visited[u] = true;
    parent[u] = p;
    depth[u] = d;
    
    for (auto& [v, w] : graph[u]) {
        if (v == p) continue;
        
        if (!visited[v]) {
            dfs(v, u, d + w);
        } else if (depth[v] < depth[u]) {
            // Találtunk egy kört
            ll cycle_total = 0;
            vector<ll> edges;
            ll x = u;
            edges.push_back(w);  // Az él ami bezárja a kört
            
            while (x != v) {
                for (auto& [next, cost] : graph[x]) {
                    if (next == parent[x]) {
                        edges.push_back(cost);
                        cycle_total += cost;
                        x = next;
                        break;
                    }
                }
            }
            
            // A körön a legrövidebb utat ki kell hagyni
            ll max_edge = 0;
            for (ll e : edges) {
                max_edge = max(max_edge, e);
            }
            total_sum += cycle_total - max_edge;
        }
    }
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    
    ll n, m;
    cin >> n >> m;
    
    graph.resize(n);
    visited.resize(n, false);
    parent.resize(n, -1);
    depth.resize(n, 0);
    
    for (ll i = 0; i < m; i++) {
        ll a, b, c;
        cin >> a >> b >> c;
        a--; b--;
        graph[a].emplace_back(b, c);
        graph[b].emplace_back(a, c);
        total_sum += c;
    }
    
    ll result = 2 * total_sum;
    
    // A körökön spórolhatunk
    visited.assign(n, false);
    dfs(0);
    
    // Megkeressük a leghosszabb utat a fában
    vector<ll> dist(n, -1);
    queue<ll> q;
    dist[0] = 0;
    q.push(0);
    
    ll farthest = 0;
    while (!q.empty()) {
        ll u = q.front(); q.pop();
        if (dist[u] > dist[farthest]) farthest = u;
        
        for (auto& [v, w] : graph[u]) {
            if (dist[v] == -1) {
                dist[v] = dist[u] + w;
                q.push(v);
            }
        }
    }
    
    dist.assign(n, -1);
    dist[farthest] = 0;
    q.push(farthest);
    
    ll diameter = 0;
    while (!q.empty()) {
        ll u = q.front(); q.pop();
        diameter = max(diameter, dist[u]);
        
        for (auto& [v, w] : graph[u]) {
            if (dist[v] == -1) {
                dist[v] = dist[u] + w;
                q.push(v);
            }
        }
    }
    
    result -= diameter;
    cout << result << endl;
    
    return 0;
}