#include <fstream>
#include <iomanip>
#include <cstring>

#define xSize 5001
#define ySize 5001
#define cSize 5001
#define fSize 101
#define useSize 101
#define grafSize 101

#define eWidth 102
#define eHeight 101

using namespace std;

ifstream in;
ofstream out;

int x[xSize];
int y[ySize];
int c[cSize];

int use[useSize];

double e[eHeight][eWidth];
double f[fSize];

struct gnod
{
    int nod;
    gnod *link;
}*graf[grafSize];

inline void addedge(int x,int y)
{
    gnod *p;

    p=new gnod;
    p->nod=y;
    p->link=graf[x];
    graf[x]=p;
}

inline void DFS(int nod)
{
    use[nod]=1;
    for(gnod *p=graf[nod];p;p=p->link)
        if(!use[p->nod])
        {
            use[p->nod]=1;
            DFS(p->nod);
        }
}

inline double abs(double x)
{
    if(x<0) return -x;
    else return x;
}

inline double min(double x,double y)
{
    if(x<y) return x;
    else return y;
}

int main()
{
    int M,N,pos;
    double aux;

    in.open("flux.in");

    in>>N>>M;
    for(int i=1;i<=M;++i)
    {
        in>>x[i]>>y[i]>>c[i];

        addedge(x[i],y[i]);
        addedge(y[i],x[i]);
    }

    in.close();

    memset(e,0,sizeof(e));
    memset(f,0,sizeof(f));
    memset(use,0,sizeof(use));

    DFS(1);

    if(!use[N])
    {
        out.open("flux.out");
        out<<"0.000\n";
        out.close();

        return 0;
    }

    for(int nod=2;nod<=N;++nod)
        if(use[nod])
            for(gnod *p=graf[nod];p;p=p->link)
                if(use[p->nod])
                {
                    ++e[nod][nod];
                    --e[nod][p->nod];
                }

    e[N][N+1]=1;

    for(int row=2,col=2;row<=N;++row)
        if(use[row])
        {
            if(e[row][col]==0)
            {
                pos=-1;
                for(int i=row+1;i<=N;++i)
                    if(use[i]&&e[i][col]!=0)
                    {
                        pos=i;
                        break;
                    }

                for(int j=col;j<=N+1;++j)
                {
                    aux=e[row][j];
                    e[row][j]=e[pos][j];
                    e[pos][j]=aux;
                }
            }

            for(int j=col+1;j<=N+1;++j)
                e[row][j]/=e[row][col];
            e[row][col]=1;

            for(int i=row+1;i<=N;++i)
                if(use[i])
                {
                    for(int j=col+1;j<=N+1;++j)
                        e[i][j]-=e[row][j]*e[i][col];
                    e[i][col]=0;
                }

            ++col;
        }

    for(int row=N,col=N;row>1;--row)
        if(use[row])
        {
            f[col]=e[row][N+1];
            for(int j=col+1;j<=N;++j)
                f[col]-=f[j]*e[row][j];
            --col;
        }

    double flux=10001;

    for(int i=1;i<=M;++i)
        if(use[x[i]]&&use[y[i]])
            flux=min(flux,c[i]/abs(f[x[i]]-f[y[i]]));

    out.open("flux.out");

    out<<fixed<<setprecision(3)<<flux<<'\n';

    out.close();

    return 0;
}