#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int n,m;
ll inf=0x3f3f3f3f;
ll p[314514];
ll h[314514],e[614514],w[614514],ne[614514],idx;
ll d[314514],f[314514][20],d1[314514][20],d2[314514][20];
ll q[314514];
struct Edge
{
	ll a,b,w;
	bool used;
	bool operator < (const Edge&t) const
	{
		return w<t.w;
	}
}  edge[314514];

void add(int a,int b,int c)
{
	e[idx]=b;
	w[idx]=c;
	ne[idx]=h[a];
	h[a]=idx++;
}

int find(int x)
{
	if(p[x]!=x)
	  p[x]=find(p[x]);
	return p[x];  
}

ll kruskal()
{
	for(int i=1;i<=n;i++)
	  p[i]=i;
	sort(edge,edge+m);
	ll res=0;
	for(int i=0;i<m;i++)
	{
		int a=find(edge[i].a),b=find(edge[i].b),w=find(edge[i].w);
		if(a!=b)
		{
			p[a]=b;
			res+=w;
			edge[i].used=true;
		}
	}  
	
	return res;
	
}

void build()
{
	memset(h,-1,sizeof h);
	for(int i=0;i<m;i++)
	  if(edge[i].used)
	  {
	  	int a=edge[i].a,b=edge[i].b,w=edge[i].w;
	  	add(a,b,w),add(b,a,w);
		}
}

void bfs()
{
	memset(d,0x3f,sizeof d);
	d[0]=0,d[1]=1;
	q[0]=1;
	int hh=0,tt=0;
	while(hh<=tt)
	{
		int t=q[hh++];
		for(int i=h[t];~i;i=ne[i])
		{
			int j=e[i];
			if(d[j]>d[t]+1)
		  {
		  	d[j]=d[t]+1;
		  	q[++tt]=j;
		  	f[j][0]=t;
		  	d1[j][0]=w[i],d2[j][0]=-inf;
		  	for(int k=1;k<=18;k++)
		  	{
		  		int anc=f[j][k-1];
		  		f[j][k]=f[anc][k-1];
		  		int dd[4]={d1[j][k-1],d2[j][k-1],d1[anc][k-1],d2[anc][k-1]};
		  		d1[j][k]=d2[j][k]=-inf;
		  		for(int u=0;u<4;u++)
		  		{
		  			int d=dd[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 a,int b,int w)
{
	static int dd[814514];
	int cnt=0;
	if(d[a]<d[b])
	  swap(a,b);
	for(int k=18;k>=0;k--)
	{
		dd[cnt++]=d1[a][k];
		dd[cnt++]=d2[a][k];
	  a=f[a][k];
	}  
	if(a!=b)
	{
		for(int k=18;k>=0;k--)
	    if(f[a][k]!=f[b][k])
	    {
	    	dd[cnt++]=d1[a][k];
	    	dd[cnt++]=d2[a][k];
	    	dd[cnt++]=d1[b][k];
	    	dd[cnt++]=d2[b][k];
	    	a=f[a][k],b=f[b][k];
			}
		dd[cnt++]=d1[a][0];
		dd[cnt++]=d1[b][0];	
	}
	
	int dist1=-inf;
	int dist2=-inf;
	for(int i=0;i<cnt;i++)  
	{
		int d=dd[i];
		if(d>dist1)
		{
			dist2=dist1;
			dist1=d;
		}
		else if(d!=dist1&&d>dist2)
		  dist2=d;
	}
	
	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,w;
		cin>>a>>b>>w;
		edge[i]={a,b,w};
	}
	
	ll sum=kruskal();
	build();
	bfs();
	
	ll res=1e18;
	for(int i=0;i<m;i++)
	  if(!edge[i].used)
	  {
	  	int a=edge[i].a,b=edge[i].b,w=edge[i].w;
	  	res=min(res,sum+lca(a,b,w));
		}
	
	cout<<res<<endl;
	
	return 0;
}