#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-5;
 
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 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]);
    }
    fin.close();
     
    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]]);
        if(!isZero(flux))
        {
            sol=mymin(sol,capacitate/flux);
        }
    }
     
afis:
    fout<<fixed<<setprecision(10);
    fout<<sol;
    fout.close();
    return 0;
}