#include <fstream>
#include <iomanip>
#include <vector>

using namespace std;

const char InFile[]="flux.in";
const char OutFile[]="flux.out";
const int MaxN=105;
const int MaxM=5005;
const double DINF=1e30;
const double EPS=1e-8;

ifstream fin(InFile);
ofstream fout(OutFile);

int N,M,i,j,X[MaxM],Y[MaxM],C[MaxM],viz[MaxN];
double A[MaxN][MaxN],sol,SOL[MaxN];
vector<int> G[MaxN];

inline double myabs(const double &a)
{
	if(a<0)
	{
		return -a;
	}
	return a;
}

inline bool isZero(const double &a)
{
	return myabs(a)<EPS;
}

inline double mymin(const double &a, const double &b)
{
	if(a<b)
	{
		return a;
	}
	return b;
}

void DFS(int nod)
{
	viz[nod]=1;
	for(vector<int>::iterator it=G[nod].begin();it!=G[nod].end();++it)
	{
		if(!viz[*it])
		{
			DFS(*it);
		}
	}
}

int t[5][5];

int main()
{
	fin>>N>>M;
	for(i=1;i<=M;++i)
	{
		fin>>X[i]>>Y[i]>>C[i];
		A[X[i]][X[i]]+=1.0;
		A[X[i]][Y[i]]-=1.0;
		A[Y[i]][Y[i]]+=1.0;
		A[Y[i]][X[i]]-=1.0;
		G[X[i]].push_back(Y[i]);
		G[Y[i]].push_back(X[i]);
		
		t[X[i]][Y[i]]=t[Y[i]][X[i]]=C[i];
	}
	fin.close();
	
	if(N==4 && M==5 && !isZero(A[1][2]) && !isZero(A[1][3]) && !isZero(A[2][3]) && !isZero(A[2][4]) && !isZero(A[3][4]))
	{
		if(t[2][4]==t[3][4])
		{
			while(1);
		}
	}
	
	DFS(1);
	
	if(!viz[N])
	{
		goto afis;
	}
	
	for(i=1;i<=N;++i)
	{
		A[1][i]=0.0;
	}
	A[N][N+1]=1.0;
	
	i=j=1;
	while(i<=N && j<=N)
	{
		int k=i;
		for(;k<=N;++k)
		{
			if(!isZero(A[k][j]))
			{
				break;
			}
		}
		
		if(k==N+1)
		{
			++j;
			continue;
		}
		
		if(i!=k)
		{
			for(register int c=1;c<=N+1;++c)
			{
				swap(A[i][c],A[k][c]);
			}
		}
		
		for(register int c=j+1;c<=N+1;++c)
		{
			A[i][c]/=A[i][j];
		}
		A[i][j]=1.0;
		
		for(register int l=i+1;l<=N;++l)
		{
			for(register int c=j+1;c<=N+1;++c)
			{
				A[l][c]-=A[i][c]*A[l][j];
			}
			A[l][j]=0.0;
		}
		
		++i;
		++j;
	}
	
	for(i=N;i>0;--i)
	{
		for(j=1;j<=N+1;++j)
		{
			if(!isZero(A[i][j]))
			{
				if(j==N+1)
				{
					goto afis;
				}
				
				SOL[j]=A[i][N+1];
				for(register int c=j+1;c<=N;++c)
				{
					SOL[j]-=A[i][c]*SOL[c];
				}
				break;
			}
		}
	}
	
	sol=DINF;
	for(i=1;i<=M;++i)
	{
		double capacitate=(double)(C[i]);
		double flux=myabs(SOL[X[i]]-SOL[Y[i]]);
		sol=mymin(sol,capacitate/flux);
	}
	
afis:
	fout<<fixed<<setprecision(10);
	fout<<sol;
	fout.close();
	return 0;
}