#include<fstream>
#include<iomanip>
#include<string.h>

using namespace std;

#define eps 0.0000001
#define max_n 110
#define d_inf 1000000000

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

int n , m , x , y , c , i1 , j1;
double sol , r_min = d_inf;
double V[max_n][max_n] , aux[max_n] , X[max_n];
double T[max_n];
int C_min[max_n][max_n];

inline int iminim(int a , int b){
    return a < b ? a : b;
}

inline double minim( double a , double b ){
    return a < b ? a : b;
}

inline double abs( double a ){
    return a < 0 ? (-a) : a;
}

inline bool zero( double a ){
    return abs(a) < eps;
}

inline void read(){

    f>>n>>m;

    for( int i = 1 ; i <= n ; i++ )
        for( int j = 1 ; j <= n ; j++ )
            C_min[i][j] = d_inf;

    for( int i = 1 ; i <= m ; i++ ){
        f>>x>>y>>c;
        V[x][y]--; V[y][x]--;
        V[x][x]++; V[y][y]++;

        C_min[x][y] = iminim(C_min[x][y] , c);
        C_min[y][x] = iminim(C_min[y][x] , c);

    }

    V[1][1] = 0;

    for( int i = 2 ; i <= n  ; i++ )
        V[1][i] = abs(V[1][i]);

    memcpy(T , V[1] , sizeof(T));

    V[1][n+1] = 1;
    V[n][n+1] = 1;

}

inline void solve(){

    int i = 1 , j = 1 , k;

    while( i <= n && j <= n ){

        for( k = i ; k <= n && zero(V[k][j]) ; k++ );

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

        if( k != i ){
            memcpy(aux , V[i] , sizeof(aux));
            memcpy(V[i] , V[k] , sizeof(aux));
            memcpy(V[k] , aux , sizeof(aux));
        }

        for( k = j + 1 ; k <= n + 1 ; k++ )
            V[i][k] /= V[i][j];

        V[i][j] = 1;

        for( i1 = i+1 ; i1 <= n ; i1++ ){
            for( j1 = j+1 ; j1 <= n+1 ; j1++ )
                V[i1][j1] -= V[i][j1] * V[i1][j];
            V[i1][j] = 0;
        }

        i++; j++;
    }

    for( k = n ; k >= 1 ; k-- ){

        if( zero(V[k][k]) && !zero(V[k][n+1]) ){
            return;
        }
        else if( !zero(V[k][k]) ){

            X[k] = V[k][n+1];

            for( i = k+1 ; i <= n ; i++ )
                X[k] -= X[i] * V[k][i];

        }
    }

    for( i = 1 ; i <= n ; i++ ){
        for( j = i+1 ; j  <= n ; j++ ){
            if( !zero(X[i] - X[j]) ){
                r_min = minim( r_min , abs( C_min[i][j] / (X[i] - X[j]) ) );
            }
        }
    }

    sol = r_min;

}


int main(){

    read();

    solve();

    g<<fixed<<setprecision(10)<<sol<<"\n";

    return 0;
}