#include <bits/stdc++.h>

using namespace std;
const int N_MAX = 255;

struct defEdge {
   int to; double cost;
}; vector<defEdge> g[N_MAX];


const double EPS = 1e-6;
double input[N_MAX][1 + N_MAX], answer[N_MAX];
bool Free[N_MAX];

/// answer[i] = distanta expected de la i la n

static inline double myabs (double x) {
   if (x < 0)
     return -x;
   return x;
}

const int UNIQUE = 1;
const int NONE = -1;
const int INF = 2;

int gauss__ (int n) {
   for (int col = 0; col < n; col ++)
      Free[col] = true;
   for (int line = 0, col = 0; line < n && col < n; line ++, col ++) {
      int chosen = line;
      for (int i = line; i < n; i ++)
         if (myabs (input[chosen][col]) < myabs (input[i][col]))
           chosen = i;
      if (myabs (input[chosen][col]) < EPS) /// n-am gasit nicio linie cu coef != 0
        continue;

      Free[col] = false;
      for (int i = col; i <= n; i ++)
         swap (input[line][i], input[chosen][i]);

      /// (k, i) devine 0 oricare ar fi k != i
      for (int i = 0; i < n; i ++) {
         if (i != line) {
           double k = input[i][col] / input[line][col];
           for (int j = col; j <= n; j ++)
              input[i][j] -= k * input[line][j];
        }
      }
   }

   for (int i = 0; i < n; i ++)
      if (!Free[i])
        answer[i] = input[i][n] / input[i][i]; /// toti coef sunt 0 in afara de i

   bool solution = true;
   for (int i = 0; i < n; i ++) {
      double sum = 0;
      for (int j = 0; j < n; j ++)
         sum += answer[j] * input[i][j];
      if (myabs (sum - input[i][n]) > EPS)
        solution = false;
   }
   if (solution == true) {
     for (int j = 0; j < n; j ++)
        if (Free[j]) /// am solutie si poate sa fie ce vrea el
          return INF;
     return UNIQUE;
   }
   return NONE;
}

int main()
{
   ifstream cin ("tunel.in");
   ofstream cout ("tunel.out");

   int n, m; cin >> n >> m;
   for (int i = 0; i < m; i ++) {
      int u, v; double cost; cin >> u >> v >> cost; u --, v --;
      g[u].push_back ({v, cost});
      g[v].push_back ({u, cost});
   }

   for (int node = 0; node < n - 1; node ++) {
      input[node][node] = g[node].size ();

      for (defEdge aux : g[node]) {
         input[node][aux.to] --;
         input[node][n] += aux.cost;
      }
   }
   gauss__ (n);
   cout << fixed << setprecision (4) << answer[0];
    return 0;
}