#include <cstdio>

#include <cstring>

#include <cassert>

#include <algorithm>

#include <cmath>

using namespace std;

#define LOOP(i,n) for(int i=1; i<=n; i++)

const int MAX_NODE = , MAX_EDGE =  * , MAX_FA = ,

INF = 0x3f3f3f3f;

struct Node;

struct Edge;

struct Node

{

    int Id, Depth;

    Edge *Head, *ToFa;

    Node *Elder[MAX_FA], *Prev;

    int MaxW[MAX_FA], MaxW2[MAX_FA];

}_nodes[MAX_NODE];

Node *GRoot;

int _vCount;

struct Edge

{

    Node *From, *To;

    Edge *Next, *Rev;

    int Weight;

    bool InTree;

    Edge(){}

    Edge(Node *from, Node *to, Edge *next, int weight)

        :From(from),To(to),Next(next),Weight(weight),InTree(false){}

}*_edges[MAX_EDGE];

int _eCount;

int Log2(int x)

{

    int cnt = ;

    while (x /= )

        cnt++;

    return cnt;

}

void Init(int vCount)

{

    _eCount = ;

    _vCount = vCount;

    GRoot =  + _nodes;

    memset(_nodes, , sizeof(_nodes));

}

Edge *AddEdge(Node *from, Node *to, int w)

{

    Edge *e = _edges[++_eCount] = new Edge(from, to, from->Head, w);

    from->Head = e;

    return e;

}

void Build(int uId, int vId, int w)

{

    Node *u = uId + _nodes, *v = vId + _nodes;

    u->Id = uId;

    v->Id = vId;

    Edge *e1 = AddEdge(u, v, w), *e2 = AddEdge(v, u, w);

    e1->Rev = e2;

    e2->Rev = e1;

}

Node *GetRoot(Node *cur)

{

    return cur->Prev ? cur->Prev = GetRoot(cur->Prev) : cur;

}

void Join(Node *a, Node *b)

{

    a->Prev = b;

}

bool CmpEdge(Edge *a, Edge *b)

{

    return a->Weight < b->Weight;

}

long long MinW;

void Kruskal()

{

    MinW = ;

    sort(_edges + , _edges + _eCount + , CmpEdge);

    int ans = , cnt = ;

    LOOP(i, _eCount)

    {

        if (cnt == _vCount)

            break;

        Edge *e = _edges[i];

        Node *root1 = GetRoot(e->From), *root2 = GetRoot(e->To);

        if (root1 != root2)

        {

            cnt++;

            e->InTree = true;

            MinW += (long long)e->Weight;

            Join(root1, root2);

        }

    }

}

void Dfs(Node *cur)

{

    cur->MaxW[] = cur->ToFa ? cur->ToFa->Weight : ;

    cur->MaxW2[] = -INF;

    int topFa = Log2(cur->Depth);

    for (int i = ; i <= topFa && cur->Elder[i - ]; i++)

    {

        cur->Elder[i] = cur->Elder[i - ]->Elder[i - ];

        cur->MaxW[i] = max(cur->MaxW[i - ], cur->Elder[i - ]->MaxW[i - ]);

        if (cur->MaxW[i - ] == cur->Elder[i - ]->MaxW[i - ])

            cur->MaxW2[i] = max(cur->MaxW2[i - ], cur->Elder[i - ]->MaxW2[i - ]);

        else if (cur->MaxW[i - ] < cur->Elder[i - ]->MaxW[i - ])

            cur->MaxW2[i] = max(cur->MaxW[i - ], cur->Elder[i - ]->MaxW2[i - ]);

        else if (cur->MaxW[i - ] > cur->Elder[i - ]->MaxW[i - ])

            cur->MaxW2[i] = max(cur->MaxW2[i - ], cur->Elder[i - ]->MaxW[i - ]);

    }

    for (Edge *e = cur->Head; e; e = e->Next)

    {

        if (!e->To->Depth && (e->InTree || e->Rev->InTree))

        {

            e->To->ToFa = e;

            e->To->Elder[] = cur;

            e->To->Depth = cur->Depth + ;

            Dfs(e->To);

        }

    }

}

void GetReady()

{

    GRoot->Depth = ;

    Dfs(GRoot);

}

void Update(int& ans, Node *a, int i, int w)

{

    ans = max(ans, a->MaxW[i] < w ? a->MaxW[i] : a->MaxW2[i]);

}

int GetAltEdgeW(Edge *e)

{

    int ans = -INF, w = e->Weight;

    Node *a = e->From, *b = e->To;

    if (a->Depth < b->Depth)

        swap(a, b);

    for (int i = Log2(a->Depth-b->Depth); i >= ; i--)

    {

        if (a->Elder[i] && a->Elder[i]->Depth >= b->Depth)

        {

            Update(ans, a, i, w);

            a = a->Elder[i];

        }

    }

    assert(a->Depth == b->Depth);

    if (a == b)

        return ans;

    for (int i = Log2(a->Depth); i >= ; i--)

    {

        if (a->Elder[i] && a->Elder[i] != b->Elder[i])

        {

            Update(ans, a, i, w);

            Update(ans, b, i, w);

            a = a->Elder[i];

            b = b->Elder[i];

        }

    }

    Update(ans, a, , w);

    Update(ans, b, , w);

    return ans;

}

long long Proceed()

{

    int delta = INF;

    for (int i = ; i <= _eCount; i++)

        if (!_edges[i]->InTree && !_edges[i]->Rev->InTree)

            delta = min(delta, _edges[i]->Weight - GetAltEdgeW(_edges[i]));

    return (long long)delta + MinW;

}

int main()

{

#ifdef _DEBUG

    freopen("c:\\noi\\source\\input.txt", "r", stdin);

#endif

    int totNode, totEdge, uId, vId, w;

    scanf("%d%d", &totNode, &totEdge);

    Init(totNode);

    for (int i = ; i <= totEdge; i++)

    {

        scanf("%d%d%d", &uId, &vId, &w);

        Build(uId, vId, w);

    }

    Kruskal();

    GetReady();

    printf("%lld\n", Proceed());

    return ;

}