#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

typedef long long ll;

struct Edge {
    int to;
    ll w;
    int id;
};

const int MAXN = 20005;
const int MAXM = 40005;

vector<Edge> adj[MAXN];
int tin[MAXN], timer;
int parent_node[MAXN], parent_eid[MAXN];
ll parent_w[MAXN];
bool is_cycle_edge[MAXM];
ll total_weight = 0;
ll total_cycle_weight = 0;

struct Cycle {
    int entry;
    vector<int> nodes;
    vector<ll> dist_from_entry; // kumulatív súly az egyik irányba
    ll total_w;
};
vector<Cycle> cycle_list;
vector<int> cycles_at_entry[MAXN];

// Körök keresése DFS-sel
void findCycles(int u, int p, int eid, ll w) {
    tin[u] = ++timer;
    parent_node[u] = p;
    parent_eid[u] = eid;
    parent_w[u] = w;

    for (auto& e : adj[u]) {
        if (e.id == eid) continue;
        if (tin[e.to]) {
            if (tin[e.to] < tin[u]) { // Visszafelé mutató él (kör talált)
                Cycle cyc;
                cyc.entry = e.to;
                is_cycle_edge[e.id] = true;
                
                vector<int> path;
                int curr = u;
                while (curr != e.to) {
                    is_cycle_edge[parent_eid[curr]] = true;
                    path.push_back(curr);
                    curr = parent_node[curr];
                }
                path.push_back(e.to);
                reverse(path.begin(), path.end());
                
                cyc.nodes = path;
                cyc.dist_from_entry.push_back(0);
                ll acc = 0;
                for(int i = 1; i < (int)path.size(); ++i) {
                    acc += parent_w[path[i]];
                    cyc.dist_from_entry.push_back(acc);
                }
                cyc.total_w = acc + e.w;
                total_cycle_weight += cyc.total_w;
                cycle_list.push_back(cyc);
            }
        } else {
            findCycles(e.to, u, e.id, e.w);
        }
    }
}

ll dp[MAXN];
ll max_saving = 0;

// Megtakarítás számítása DP-vel
void runDP(int u, int p) {
    max_saving = max(max_saving, dp[u]);
    
    // 1. Haladás hidakon (pozitív megtakarítás)
    for (auto& e : adj[u]) {
        if (e.to == p || is_cycle_edge[e.id]) continue;
        dp[e.to] = dp[u] + e.w;
        runDP(e.to, u);
    }
    
    // 2. Haladás körökben (büntetés a végállomás miatt)
    for (int cid : cycles_at_entry[u]) {
        auto& cyc = cycle_list[cid];
        for (int i = 1; i < (int)cyc.nodes.size(); ++i) {
            int v = cyc.nodes[i];
            ll d_cw = cyc.dist_from_entry[i];
            ll d_ccw = cyc.total_w - d_cw;
            dp[v] = dp[u] - min(d_cw, d_ccw); // A rövidebb út a büntetés
            runDP(v, -1); 
        }
    }
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    
    int n, m;
    if (!(cin >> n >> m)) return 0;
    
    for (int i = 0; i < m; ++i) {
        int u, v; ll w;
        cin >> u >> v >> w;
        adj[u].push_back({v, w, i});
        adj[v].push_back({u, w, i});
        total_weight += w;
    }
    
    findCycles(1, 0, -1, 0);
    
    for (int i = 0; i < (int)cycle_list.size(); ++i) {
        cycles_at_entry[cycle_list[i].entry].push_back(i);
    }
    
    dp[1] = 0;
    runDP(1, 0);
    
    // Alapár: minden élt 2x járunk be, kivéve a köröket, amiket elég 1x [cite: 8]
    ll total_return = 2 * total_weight - total_cycle_weight;
    cout << total_return - max_saving << endl;
    
    return 0;
}