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

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

#define eWidth 102
#define eHeight 101

#define EPS 1e-4

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]) 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;
}

inline bool zero(double x)
{
    if(abs(x)<EPS) return true;
    else return false;
}

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;
    }

    use[N+1]=1;

    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]+=1;
                    e[nod][p->nod]-=1;
                }

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

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

                for(int j=k;j<=N+1;++j)
                    if(use[j])
                    {
                        aux=e[k][j];
                        e[k][j]=e[pos][j];
                        e[pos][j]=aux;
                    }
            }

            for(int j=k+1;j<=N+1;++j)
                if(use[j]) e[k][j]/=e[k][k];
            e[k][k]=1;

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

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

    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;
}