#include <fstream>
#include <iomanip>
#include <cmath>

using namespace std;

const double EPS = 1e-8;
const double INF = 1e+9; //infinit
const int DIM = 102;

ifstream f("flux.in");
ofstream g("flux.out");

int N, M;
double C[DIM][DIM], A[DIM][DIM], F[DIM][DIM];
int D[DIM][DIM];
double X[DIM];
bool Viz[DIM];
double sol = 0.0;

void gauss()
{
    int i = 2, j = 2, k, t;
    while(i <= N && j <= N)
    {
        for(k = i; k <= N; k++)
            if(abs(A[k][j]) > EPS)
                break;
        if(k == N + 1)
        {
            j++;
            continue;
        }
        if(k != i)
            for(t = j; t <= N + 1; t++)
                swap(A[i][t], A[k][t]);
        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++;
    }
}

void solutie()
{
    for(int i = N; i >= 2; i--)
        for(int j = i; j <= N + 1; j++)
            if(abs(A[i][j]) > EPS)
            {
                X[j] = A[i][N + 1];
                for(int t = j + 1; t <= N; t++)
                    X[j] -= A[i][t] * X[t];
                break;
            }
}

void DFS(int nod)
{
    Viz[nod] = 1;
    for(int i = 1; i <= N; i++)
        if(D[nod][i] != 0)
        {
            F[nod][i] = X[i] - X[nod];
            F[i][nod] = -F[nod][i];
            if(Viz[i] == 0)
                DFS(i);
        }
}

int main()
{
    int i, j, x, y, z;
    f >> N >> M;
    for(i = 1; i <= N; i++)
        for(j = 1; j <= N; j++)
            C[i][j] = INF;
    for(i = 1; i <= M; i++)
    {
        f >> x >> y >> z;
        if(z < C[x][y])
            C[x][y] = C[y][x] = z;
        D[x][y]++, D[y][x]++;
        A[x][x]++, A[y][y]++;
        A[x][y]--, A[y][x]--;
    }
    A[N][N + 1] = 1;
    gauss();
    solutie();
    DFS(1);
    if(Viz[N] != 0)
    {
        sol = INF;
        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]);
    }
    g << setprecision(3) << fixed << sol;
    return 0;
}