#include <fstream>
#include <bitset>
#include <iomanip>
#define DIM 103
#define EPS 0.000000001
 
using namespace std;
ifstream fin("flux.in");
ofstream fout("flux.out");
 
double C[DIM][DIM], A[DIM][DIM], F[DIM][DIM];
double aux, sol, z;
double X[DIM];
 
int D[DIM][DIM];
 
bitset<DIM> V;
int x, y;
 
int n, i, j, k, t, m;
 
void dfs(int nod) {
    V[nod] = 1;
    for (int i=1;i<=n;i++)
        if (D[nod][i] != 0 && V[i] == 0) {
            F[nod][i] = X[i] - X[nod];
            F[i][nod] = -F[nod][i];
            dfs(i);
        } else {
            if (D[nod][i]!=0) {
                F[nod][i] = X[i] - X[nod];
                F[i][nod] = -F[nod][i];
            }
        }
}
 
int main() {
    fin>>n>>m;
 
    for (i=1;i<=n;i++)
        for (j=1;j<=n;j++)
            C[i][j] = 10010;
 
    for (i=1;i<=m;i++) {
        fin>>x>>y>>z;
//        if (z == 0)
//            continue;
        C[x][y] = min(z, C[x][y]);
        C[y][x] = C[x][y];
        D[x][y]++;
        D[y][x]++;
    }
 
    for (i=2;i<=n;i++) {
        // scriem ecuatia de conservare in nodul i
        for (j=1;j<=n;j++)
            if (j!=i) {
                A[i][j] = D[i][j];
                A[i][i] -= D[i][j];
            }
    }
 
    A[n][n+1] = -1;
 
    i = 2;
    j = 2;
    while (i<=n) {
        for (k=i;k<=n;k++)
            if (A[k][j] > EPS || A[k][j]<-EPS) {
                break;
            }
        if (k == n+1) {
            j++;
            continue;
        }
        if (k!=i) {
            for (t=j;t<=n+1;t++) {
                aux = A[i][t];
                A[i][t] = A[k][t];
                A[k][t] = aux;
            }
        }
 
        for (t = j+1;t<=n+1;t++)
            A[i][t] /= A[i][j];
        A[i][j] = 1;
 
        for (k=i+1;k<=n;k++) {
            for (t=j+1;t<=n+1;t++)
                A[k][t] -= (A[i][t] * A[k][j]);
            A[k][j] = 0;
        }
        i++;
        j++;
    }
 
    for (i=n;i>=2;i--) {
        for (j=2;j<=n+1;j++)
            if (A[i][j] > EPS || A[i][j]<-EPS)
                break;
        X[j] = A[i][n+1];
        for (t=j+1;t<=n;t++)
            X[j] -= A[i][t] * X[t];
    }
 
    dfs(1);
 
    if (V[n] == 0) {
        fout<<0.0000;
        return 0;
    }
 
    sol = 1000000000;
 
    for (i=1;i<=n;i++)
        for (j=1;j<=n;j++)
            if (D[i][j] && F[i][j]>0) {
 
                sol = min(sol, C[i][j]/F[i][j]);
            }
    fout<<setprecision(3)<<fixed<<sol;
    return 0;
}