program pr;

const
 maxn = 2000;
 maxp = 20000;
 free = 0;
 used = 1;
var
   n  : 1..maxn;
   p  : 1..maxp;
   i, j : integer;
   pred, rank : array [1..maxn] of integer;
   b, e : array [1..maxp] of boolean;
   Key : array [1..max-1] of integer;
  Answer, MinAnswer, CurAnswer: longint;
  u, v: integer;
  R: array [1..maxp] of integer;
  
procedure inputdata;
var i:integer;
 begin
  assign (input,'input. txt'); reset(input);
  readln(n,p);
  for i:=1 to p do
    readln(b[i],e[i],r[i]);
  close(input);
 end;

function Partition(p, rr:longint):longint;
  var
    i, j, z : longint;
	x, y : single;
begin  
	  x:= R[p];
	  i:= p - 1;
	  j:= rr + 1;
	  while i < j do
		begin
		  repeat j:= j - 1 until R[j] ≤ x;
		  repeat i:= i + 1 until R[i] ≥ x;
		  if i < j then
			  begin
				y:= R[i]; R[i]:= R[j]; R[j]:= y;
				z:= B[i]; B[i]:= B[j]; B[j]:= z;
				z:= E[i]; E[i]:= E[j]; E[j]:= z;
			  end;
		end;
		Partition:= j;		  
end;  

procedure QuickSortR(p,rr:longint);
var
	q: longint;
begin
	if p < rr then
	begin
		 q:=Partition(p,rr);
		 QuickSortR(p,q);
		 QuickSortR(q+1, rr);
	end;
end;

procedure makeset(x:longint);
 begin
  pred[x]:=x;
  rank[x]:=0;
 end;

function findset(x:longint):longint;
 begin
  if x <> pred[x] thenpred[x]:=findset(pred[x]);
  findset:=pred[x];
 end;

procedure link(x,y: longint);
 begin
 if rank[x] > rank[y] 
  then pred[y]:=x
 else 
  begin 
   pred[x]:=y;
   if rank[x]=rank[y] 
    then inc(rank[y]); 
  end;
 end;

procedure union(x,y:longint); 
 begin
  link(findset(x),findset(y));
 end;

procedure mintree_kruskal_1;
var i : integer;
begin 
 answer:=0; j:=0;
 for i:=1 to n do makeset(i);
 i:=1; 
 while j <> n-1 do 
 begin 
    if findset(B[i]) &t;> findSet(E[i]) then 
    begin 
       answer:= answer+r[i]; 
       inc(j); Key[j]:=i; 
       Union(B[i],E[i]);
    end; 
    inc(i); 
  end; 
end;

procedure MinTree_Kruskal_2; 
   var 
      i : longint;
      FindSetConst: array [1..MaxN] of integer; 
   begin 
      While J <> N-1 do 
        begin 
           if (NotMasked[i]) 
           then 
           if (Findset(B[i]) <> FindSet(E[i])) 
           then 
              begin 
                Answer:=Answer+R[i];
                inc(j); 
              end;
           inc(i);
       end; 
   end;

begin 
  InputData;
  QuickSortR(1,P);
  MinTree_Kruskal_1;
  for i:=1 to P do NotMasked[i]:=true;
  CurAnswer:=maxlongInt; MinAnswer:=Answer;
  for v:=1 to N-1 do 
      begin 
        NotMasked[key[v]]:=false; Answer:=MinAnswer-R[key[v]];
        for  i:=1 to  N do  Makeset(i);
        for  u:=1 to  N-1 do  
        if  NotMasked[key[u]] 
        then  
           begin  
               Union(B[key[u]],E[key[u]]);
              NotMasked[key[u]]:=false;
           end ; 
      i:=key[v]+1; j:=N-2;
      MinTree_Kruska1_2; 
      if Answer < CurAnswer then CurAnswer:=Answer;
      for u:=1 to N-1 do NotMasked[key[u]]:=true; 
    end; 
  assign (output,'secret.out'); rewrite(output);
  writeln(CurAnswer);
  close(output);
end.