#include <fstream>
#include <vector>
#include <utility>
#include <iomanip>
#include <cmath>
#include <cstring>

#define maxn 101
#define inf 1<<30
#define eps 1e-9
#define vintp vector<pair<int,double> >::iterator

using namespace std;

ifstream fin("flux.in");
ofstream fout("flux.out");

double a[maxn][maxn],val[maxn],b[maxn],ans=inf;
int G[maxn][maxn];
int n,m,x,y;
double c;
bool viz[maxn];

void swaplines (int i, int j)
{
    for (int k=1; k<=n; ++k)
    {
        swap(a[i][k],a[j][k]);
    }
}

double min (double a, double b)
{
    if (a<b) return a;
    return b;
}

int main()
{
    fin>>n>>m;

    memset (G,1,sizeof(G));

    for (int i=1; i<=m; ++i)
    {
        fin>>x>>y>>c;

        a[x][y]--;
        a[x][x]++;

        a[y][x]--;
        a[y][y]++;

        G[x][y] = min (G[x][y],c);
        G[y][x] = min (G[y][x],c);
    }

    b[1] = -1;
    b[n] = 1;

    for (int i=1; i<=n; ++i)
    {
        int j=i,ok=0;

        for (int k=i; k<=n; ++k)
        {
            if (fabs(a[k][j]) > eps)
            {
                ok=1;
                swaplines (k,i);
                break;
            }
        }

        if (!ok) continue;

        for (int jj=j+1; jj<=n; ++jj)
        {
            a[i][jj] /= a[i][j];
        }
        b[i] /= a[i][j];
        a[i][j] = 1;

        for (int ii=i+1; ii<=n; ++ii)
        {
            for (int jj=j+1; jj<=n; ++jj)
            {
                a[ii][jj] -= (a[i][jj]*a[ii][j]);
            }
            b[ii] -= (b[i]*a[ii][j]);
            a[ii][j] = 0;
        }
    }

    for (int i=n; i>=1; --i)
    {
        int j = i;

        if (fabs(b[i]) > eps && fabs(a[i][j]) > eps)
        {
            val[j] = b[i];

            for (int k=i-1; k>=1; --k)
            {
                b[k] -= a[k][j]*b[i];
            }
        }

        else if (fabs(b[i]) > eps && fabs (a[i][j]) < eps)
        {
            fout<<"0.000";
            return 0;
        }
    }

    for (int i=1; i<=n; ++i)
        for (int j=i+1; j<=n; ++j)
    {
        if (fabs(val[j]-val[i]) > eps)
        ans = min (fabs(double(G[i][j])/(val[j]-val[i])),ans);
    }

    fout<<fixed<<setprecision(3)<<ans;
}