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