#include <cassert>
#include <cmath>

#include <algorithm>
#include <fstream>
#include <iostream>
#include <vector>
using namespace std;
const int MAX_N = 105;
const double eps = 1.e-5;

vector<int> graph[MAX_N];
int line[MAX_N];
int capacity[MAX_N][MAX_N];
int x[MAX_N], y[MAX_N], c[MAX_N];
int edges[MAX_N][MAX_N];
double coef[MAX_N][MAX_N];
double flux[MAX_N];

int main() {
    ifstream fin("flux.in");
    ofstream fout("flux.out");
    int n, m;
    fin >> n >> m;
    for (int i = 1; i <= m; ++ i) {
        fin >> x[i] >> y[i] >> c[i];
        ++ edges[x[i]][y[i]];
        ++ edges[y[i]][x[i]];
        graph[x[i]].push_back(y[i]);
        graph[y[i]].push_back(x[i]);
    }
    for (int i = 2; i < n; ++ i) {
        for (vector<int> :: iterator it = graph[i].begin(); it != graph[i].end(); ++ it) {
            coef[i][*it] += 1.0;
        }
        coef[i][i] = -1.0 * graph[i].size();
    }
    coef[1][1] = 1;
    coef[n][n] = coef[n][n + 1] = 1.0;
    int i = 1, j = 1;
    while (i <= n) {
        int last = 0;
        for (int k = j; k <= n; ++ k) {
            if (fabs(coef[k][i]) >= eps) {
                last = k;
                break;
            }
        }
        if (last == 0) {
            line[i] = -1;
            ++ i;
            continue;
        }
        for (int k = 1; k <= n + 1; ++ k) {
            swap(coef[j][k], coef[last][k]);
        }
        for (int k = j + 1; k <= n; ++ k) {
            if (fabs(coef[k][i]) >= eps) {
                double raport = coef[k][i] / coef[j][i];
                for (int p = 1; p <= n + 1; ++ p) {
                    coef[k][p] = coef[k][p] - coef[j][p] * raport;
                }
            }
        }
        line[i] = j;
        ++ i; ++ j;
    }
    for (int i = n; i >= 2; -- i) {
        if (line[i] != -1) {
            for (int p = 1; p <= n; ++ p) {
                if (i != p) {
                    coef[line[i]][n + 1] -= coef[line[i]][p] * flux[p];
                }
            }
            flux[i] = coef[line[i]][n + 1] / coef[line[i]][i];
        }
    }
    double answer = 0, p = 1.e9;
    for (int i = 1; i <= m; ++ i) {
        p = min(p, fabs(c[i] / (flux[y[i]] - flux[x[i]])));
    }


    for (vector<int> :: iterator it = graph[n].begin(); it != graph[n].end(); ++ it) {
        answer += p * (flux[n] - flux[*it]);
        assert(flux[n] >= flux[*it]);
    }

    fout << answer << "\n";
    return 0;
}