#include <fstream>
#include <iomanip>

using namespace std;

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

const double eps = 0.0000001;

int n, m;
double mat[105][105], sol[105];

struct muchii {
    int a, b, c;
}v[5005];

void schimb(int a, int b)
{
    for(int i = 1; i <= n + 1; i++)
        swap(mat[a][i], mat[b][i]);
}

int main()
{
    fin >> n >> m;
    for(int i = 1; i <= m; i++)
    {
        fin >> v[i].a >> v[i].b >> v[i].c;
        if(v[i].a > v[i].b)
            swap(v[i].a, v[i].b);
        if(v[i].c == 0)
            continue;
        if(v[i].a != 1)
        {
            mat[v[i].a][v[i].a]--;
            mat[v[i].a][v[i].b]++;
        }
        if(v[i].b != n)
        {
            mat[v[i].b][v[i].b]--;
            mat[v[i].b][v[i].a]++;
        }
    }
    mat[1][1] = 1;
    mat[n][n + 1] = 1;
    mat[n][n] = 1;

    int i = 1, j = 1;
    while(i <= n && j <= n)
    {
        int k;
        for(k = i; k <= n; k++)
            if(mat[k][j] < -eps || mat[k][j] > eps)
                break;
        if(k == n + 1)
        {
            j++;
            continue;
        }
        if(k != i)
            schimb(k, i);
        for(k = j + 1; k <= n + 1; k++)
            mat[i][k] = mat[i][k] / mat[i][j];
        mat[i][j] = 1;
        for(k = i + 1; k <= n; k++)
        {
            for(int l = j + 1; l <= n + 1; l++)
                mat[k][l] -= mat[k][j] * mat[i][l];
            mat[k][j] = 0;
        }
        i++, j++;
    }
    for(i = n; i > 0; i--)
    {
        for(int j = 1; j <= n + 1; j++)
        {
            if(mat[i][j] > eps || mat[i][j] < -eps)
            {
                if(j == n + 1)
                {
                    fout << '0';
                    return 0;
                }
                sol[j] = mat[i][n + 1];
                for(int k = j + 1; k <= n; k++)
                    sol[j] -= sol[k] * mat[i][k];
                break;
            }
        }
    }

    double mini = 2e9, ans = 0;
    for(int i = 1; i <= m; i++)
    {
        double cost = abs(sol[v[i].a] - sol[v[i].b]);
        mini = min(mini, v[i].c / cost);
    }
    for(int i = 1; i <= m; i++)
        if(v[i].b == n)
            ans += mini * abs(sol[v[i].a] - sol[v[i].b]);
    fout << fixed << setprecision(3) << ans << '\n';
    return 0;
}