#include<fstream>
#include<iomanip>
#include<string.h>

using namespace std;

#define eps 0.0000001
#define max_n 110
#define d_inf 1000000000

ifstream f("flux.in");
ofstream g("flux.out");

int n , m , x , y , c , i1 , j1;
double sol , r_min = d_inf;
double V[max_n][max_n] , aux[max_n] , X[max_n];
double T[max_n];
int C_min[max_n][max_n];
bool Fr[max_n];

inline int iminim(int a , int b){
	return a < b ? a : b;
}

inline double minim( double a , double b ){
	return a < b ? a : b;
}

inline double abs( double a ){
	return a < 0 ? (-a) : a;
}

inline bool zero( double a ){
	return abs(a) < eps;
}

void dfs( int nod ){
	Fr[nod] = 1;
	for( int i = 1 ; i <= n ; i++ )
		if( V[nod][i] && !Fr[i] )
			dfs(i);
}

inline void read(){
	
	f>>n>>m;
	
	for( int i = 1 ; i <= n ; i++ )
		for( int j = 1 ; j <= n ; j++ )
			C_min[i][j] = d_inf;
	
	for( int i = 1 ; i <= m ; i++ ){
		f>>x>>y>>c;
		V[x][y]--; V[y][x]--;
		V[x][x]++; V[y][y]++;
		
		C_min[x][y] = iminim(C_min[x][y] , c);
		C_min[y][x] = C_min[x][y];
		
	}
	
	dfs(1);
	
	if( Fr[n] == 0 )
		return;
	
	V[1][1] = 0;
	
	for( int i = 2 ; i <= n  ; i++ )
		V[1][i] = abs(V[1][i]);
	
	memcpy(T , V[1] , sizeof(T));
	
	V[1][n+1] = 1;
	V[n][n+1] = 1;
	
}

inline void solve(){
	
	int i = 1 , j = 1 , k;
	
	while( i <= n && j <= n ){
		
		for( k = i ; k <= n && zero(V[k][j]) ; k++ );
		
		if( k > n ){
			j++;
			continue;
		}
		
		if( k != i ){
			memcpy(aux , V[i] , sizeof(aux));
			memcpy(V[i] , V[k] , sizeof(aux));
			memcpy(V[k] , aux , sizeof(aux));
		}
		
		for( k = j + 1 ; k <= n + 1 ; k++ )
			V[i][k] /= V[i][j];
		
		V[i][j] = 1;
		
		for( i1 = i+1 ; i1 <= n ; i1++ ){
			for( j1 = j+1 ; j1 <= n+1 ; j1++ )
				V[i1][j1] -= V[i][j1] * V[i1][j];
			V[i1][j] = 0;
		}
		
		i++; j++;
	}
	
	for( k = n ; k >= 1 ; k-- ){
		
		if( zero(V[k][k]) && !zero(V[k][n+1]) ){
			return;
		}
		else if( !zero(V[k][k]) ){
			
			X[k] = V[k][n+1];
			
			for( i = k+1 ; i <= n ; i++ )
				X[k] -= X[i] * V[k][i];
			
		}
	}
	
	for( i = 1 ; i <= n ; i++ ){
		for( j = i+1 ; j  <= n ; j++ ){
			if( !zero(X[i] - X[j]) ){
				r_min = minim( r_min , abs( C_min[i][j] / (X[i] - X[j]) ) );
			}
		}
	}
	
	sol = r_min;
	
	/*if( r_min == d_inf )
		r_min = 0.0;
	
	for( i = 2 ; i <= n ; i++ ){
		if( T[i] != 0 )
			sol += r_min * X[i] * T[i];
	}*/
	
}


int main(){
	
	read();
	
	if( Fr[n] )
		solve();
	
	g<<fixed<<setprecision(3)<<sol<<"\n";
	
	return 0;
}