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

using namespace std;

ifstream f("flux.in");
ofstream g("flux.out");
const double eps = 1e-4, INF = 1e9;
int N, M, a, b;
bool viz[102], D[102][102];
double c, X[102], A[102][102], F[102][102], C[102][102];

void gauss()
{
    int i = 2, j = 2;
    while(i <= N && j <= N)
    {
        if(abs(A[i][j]) <= eps) //if(A[i][i] == 0)
        {
            bool praf = 0;
            for(int k = i + 1; k <= N; k++)
                if(abs(A[k][j]) > eps) //if(A[j][i] != 0)
                {
                    for(int l = j; l <= N + 1; l++)
                        swap(A[i][l], A[k][l]);
                    praf = 1;
                    break;
                }
            if(praf == 0)
            {
                j++;
                continue;
            }
        }
        for(int k = j + 1; k <= N + 1; k++)
            A[i][k] /= A[i][j];
        A[i][j] = 1;
        for(int l = i + 1; l <= N; l++)
        {
            for(int k = j + 1; k <= N + 1; k++)
                A[l][k] -= A[i][k] * A[l][j];
            A[l][j] = 0;
        }
        i++, j++;
    }
}

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

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

int main()
{
    f >> N >> M;
    for(int i = 1; i <= N; i++)
        for(int j = 1; j <= N; j++)
            C[i][j] = INF;
    for(int i = 1; i <= M; i++)
    {
        f >> a >> b >> c;
        A[a][a]++, A[b][b]++;
        A[a][b]--, A[b][a]--;
        D[a][b] = D[b][a] = 1;
        if(c < C[a][b])
            C[a][b] = C[b][a] = c;
    }
    A[N][N + 1] = 1;
    gauss();
    detsol();
    DFS(1);
    if(viz[N] == 0)
    {
        g << 0;
        return 0;
    }
    double sol = INF;
    for(int i = 1; i <= N; i++)
        for(int j = 1; j <= N; j++)
            if(D[i][j] && F[i][j] > 0)
                sol = min(sol, C[i][j] / F[i][j]);
    g << fixed << setprecision(3) << sol;

    return 0;
}