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

#define fSize 102
#define grafSize 102
#define levelSize 102

#define eWidth 102
#define eHeight 102
#define costWidth 102
#define costHeight 102

#define EPS 1e-4

using namespace std;

ifstream in;
ofstream out;

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

int cost[costHeight][costWidth];
int level[levelSize];

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

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)
{
    for(gnod *p=graf[nod];p;p=p->link)
        if(level[p->nod]==0)
        {
            level[p->nod]=level[nod]+1;

            ++e[nod][nod];
            --e[nod][p->nod];
            --e[p->nod][nod];
            ++e[p->nod][p->nod];

            DFS(p->nod);
        }
        else
        if(level[p->nod]>level[nod])
        {
            ++e[nod][nod];
            --e[nod][p->nod];
            --e[p->nod][nod];
            ++e[p->nod][p->nod];
        }
}

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

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

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

    in.open("flux.in");

    in>>N>>M;
    for(;M;--M)
    {
        in>>x>>y;
        in>>cost[x][y];
        addedge(x,y);
        addedge(y,x);
    }

    in.close();

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

    level[1]=1;
    DFS(1);

    //Gauss

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

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

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

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

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

    double flux=10001;

    for(int nod=1;nod<=N;++nod)
        for(gnod *p=graf[nod];p;p=p->link)
            if(cost[nod][p->nod]!=0)
                flux=min(flux,cost[nod][p->nod]/abs(f[p->nod]-f[nod]));

    out.open("flux.out");

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

    out.close();

    return 0;
}