#include <bits/stdc++.h>
using namespace std;
typedef long double f80;

const int SPQR = 256; // Ave Imperator, morituri te salutant!
const f80 EPS = 1e-9;

struct EDGE {
    int v, w;

    inline EDGE() { }
    inline EDGE(int _v, int _w) {
        v = _v;
        w = _w; } };

vector<EDGE> g[SPQR];
vector<f80> vals;
valarray<f80> gs[SPQR];

inline bool eq(const f80 &a, const f80 &b) {
    return abs(a - b) < EPS; }

int main(void) {
    ifstream fi("tunel.in");
    ofstream fo("tunel.out");
    int n, m, u, v, w;

    fi >> n >> m;
    for (int i = 1; i <= m; ++i) {
        fi >> u >> v >> w;
        if (u != n) g[u].emplace_back(v, w);
        if (v != n) g[v].emplace_back(u, w); }

    if (n == 1) {
        sort(g[1].begin(), g[1].end(), [](const EDGE &a, const EDGE &b) { return a.w < b.w; });
        fo << g[1].front().w << '\n'; }

    for (int i = 1; i <= n; ++i) {
        gs[i].resize(n + 2);
        for (const auto &j: g[i]) {
            gs[i][j.v]+= 1.0;
            gs[i][n + 1]+= j.w; }
        gs[i][i] = -int(g[i].size()); }
    gs[n][n] = 1.0;

    for (int k, i = 1, j = 1; i <= n && j <= n; ++j) {
        if (eq(gs[i][j], 0.0)) {
            for (k = i; k <= n; ++k) {
                if (!eq(gs[k][j], 0.0)) {
                    swap(gs[i], gs[k]);
                    break; } }
            if (k > n)
                continue; }
        assert(!eq(gs[i][j], 0.0));
        for (k = 1; k <= n; ++k) if (k != i && !eq(gs[k][j], 0.0))
            gs[k]-= gs[i] * (gs[k][j] / gs[i][j]);
        ++i; }

    vals.resize(n + 1);
    for (int i = 1; i <= n; ++i)
        for (int j = 1; j <= n; ++j)
            if(!eq(gs[i][j], 0.0))
                vals[j] = gs[i][n + 1] / gs[i][j];

    fo << setprecision(7) << -vals[1] << '\n';

    return 0; }