#include <bits/stdc++.h>

using namespace std;
using ld = long double;
using mat = vector<vector<ld>>;
const ld EPS = 1e-12;

pair<vector<int>, int> RowEchelon(mat& A) {
  int n = A.size(), m = A[0].size(), sgn = 1; 
  vector<int> piv;
  for (int i = 0, rnk = 0; i < m && rnk < n; ++i) {
    for (int j = rnk + 1; j < n; ++j) 
      if (abs(A[j][i]) > abs(A[rnk][i]))
        swap(A[j], A[rnk]), sgn = -sgn;
    if (abs(A[rnk][i]) < EPS) continue;
    for (int j = 0; j < n; ++j) {
      ld coef = A[j][i] / A[rnk][i];
      if (j == rnk || abs(coef) < EPS) continue;
      for (int k = 0; k < m; ++k)
        A[j][k] -= coef * A[rnk][k];
    }
    piv.push_back(i); ++rnk;
  }
  return {piv, sgn};
}
vector<ld> SolveLinear(mat A) {
  int m = A[0].size() - 1;
  auto piv = RowEchelon(A).first;
  if (piv.size() > m) return {};
  vector<ld> sol(m, 0.);
  for (int i = 0; i < (int)piv.size(); ++i)
    sol[piv[i]] = A[i][m] / A[i][i];
  return sol;
}

int main() {
  ifstream cin("flux.in");
  ofstream cout("flux.out");
  
  int n, m; cin >> n >> m;
  vector<tuple<int, int, int>> cons;
  for (int i = 0; i < m; ++i) {
    int a, b, c; cin >> a >> b >> c;
    cons.emplace_back(a - 1, b - 1, c);
  }

  mat A(n, vector<ld>(n + 1));
  A[0][0] = 1; A[n - 1][n] = 1;
  for (auto itr : cons) {
    int a, b; tie(a, b, ignore) = itr;
    if (a > 0) A[a][a] += 1, A[a][b] -= 1;
    if (b > 0) A[b][b] += 1, A[b][a] -= 1;
  }
  auto pi = SolveLinear(A);

  ld ans = 1e18;
  for (auto itr : cons) {
    int a, b, c; tie(a, b, c) = itr;
    ans = min(ans, c / abs(pi[b] - pi[a]));
  }
  cout << fixed << setprecision(3) << ans << endl;

  return 0;
}