#include <bits/stdc++.h>

using namespace std;

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

vector<pair <int,int> >v[301];
int n,m,i,j,k,x,col,y,z,vecin;
double suma,sol[301],a[301][301];

int main()
{
    f>>n>>m;
    for(i=1; i<=m; i++)
    {
        f>>x>>y>>z;

        v[x].push_back({y,z});
        v[y].push_back({x,z});
    }

    // sol[i] = timp mediu de parcurgere de la i la n
    // pentru un nod i, sol[i] = (dist[i][j1]+sol[j1] + dist[i][j2]+sol[j2] + ... + dist[i][jk]+sol[jk]) / k;
    // unde j1, j2, ... jk sunt vecinii care intra in i


    sol[n]=0; // evident ca timpul de a ajunge de la n la n este 0

    // acum fac sistemul gauss
    for(i=n-1; i>=1; i--)
    {
        if(v[i].size()!=0)
        {
            suma=0;
            for(j=0; j<v[i].size(); j++)
            {
                vecin=v[i][j].first;
                suma-=v[i][j].second;

                a[i][vecin]+=(double)(1.0/v[i].size());
            }
            a[i][i]=-1.0;
            a[i][n+1]=suma/v[i].size();
        }
    }

    // gauss
    i=1;
    j=1;
    while(i<=n && j<=n)
    {
        k=j;
        while(a[k][j]==0 && k<=n)k++;

        if(k==n+1)
        {
            i++;
            j++;
            continue;
        }

        if(k!=i)
        {
            // interschimb k si i
            for(col=j; col<=n+1; col++)
            {
                swap(a[i][col],a[k][col]);
            }
        }

        // de acum lucrez cu i, nu cu k
        for(col=j+1; col<=n+1; col++)
            a[i][col]=a[i][col]/a[i][j];

        a[i][j]=1;

        for(k=i+1; k<=n; k++)
        {
            for(col=j+1; col<=n+1; col++)
                a[k][col]-=a[k][j]*a[i][col];

            a[k][j]=0;
        }

        i++;
        j++;
    }

    // acum luam solutiile
    for(i=n; i>=1; i--)
    {
        for(j=1; j<=n+1; j++)
            if(abs(a[i][j]) > 0.0001)
            {
                if(j==n+1)
                {
                    g<<0;
                    return 0;
                }

                sol[j]=a[i][n+1];
                for(k=j+1; k<=n; k++)
                {
                    sol[j]-=sol[k]*a[i][k];
                }
                break;
            }
    }


    g<<fixed<<setprecision(3)<<sol[1];

    return 0;
}