#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
istream &operator>>(istream &in, pair<T1, T2> &a) {
  in >> a.first >> a.second;
  return in;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &out, pair<T1, T2> a) {
  out << a.first << " " << a.second;
  return out;
}
template <typename T, typename T1>
T maxs(T &a, T1 b) {
  if (b > a) a = b;
  return a;
}
template <typename T, typename T1>
T mins(T &a, T1 b) {
  if (b < a) a = b;
  return a;
}
const long double EPS = 1e-9;
struct simplex {
  long long m, n;
  vector<long long> B, N;
  vector<vector<long double>> D;
  simplex(const vector<vector<long double>> &A, const vector<long double> &b,
          const vector<long double> &c)
      : m(b.size()),
        n(c.size()),
        N(n + 1),
        B(m),
        D(m + 2, vector<long double>(n + 2)) {
    for (long long i = 0; i < m; i++)
      for (long long j = 0; j < n; j++) D[i][j] = A[i][j];
    for (long long i = 0; i < m; i++) {
      B[i] = n + i;
      D[i][n] = -1;
      D[i][n + 1] = b[i];
    }
    for (long long j = 0; j < n; j++) {
      N[j] = j;
      D[m][j] = -c[j];
    }
    N[n] = -1;
    D[m + 1][n] = 1;
  }
  void Pivot(long long r, long long s) {
    long double inv = 1.0 / D[r][s];
    for (long long i = 0; i < m + 2; i++)
      if (i != r)
        for (long long j = 0; j < n + 2; j++)
          if (j != s) D[i][j] -= D[r][j] * D[i][s] * inv;
    for (long long j = 0; j < n + 2; j++)
      if (j != s) D[r][j] *= inv;
    for (long long i = 0; i < m + 2; i++)
      if (i != r) D[i][s] *= -inv;
    D[r][s] = inv;
    swap(B[r], N[s]);
  }
  bool Simplex(long long phase) {
    long long first = phase == 1 ? m + 1 : m;
    while (true) {
      long long s = -1;
      for (long long j = 0; j <= n; j++) {
        if (phase == 2 && N[j] == -1) continue;
        if (s == -1 || D[first][j] < D[first][s] ||
            D[first][j] == D[first][s] && N[j] < N[s])
          s = j;
      }
      if (D[first][s] > -EPS) return true;
      long long r = -1;
      for (long long i = 0; i < m; i++) {
        if (D[i][s] < EPS) continue;
        if (r == -1 || D[i][n + 1] / D[i][s] < D[r][n + 1] / D[r][s] ||
            (D[i][n + 1] / D[i][s]) == (D[r][n + 1] / D[r][s]) && B[i] < B[r])
          r = i;
      }
      if (r == -1) return false;
      Pivot(r, s);
    }
  }
  long double Solve(vector<long double> &first) {
    long long r = 0;
    for (long long i = 1; i < m; i++)
      if (D[i][n + 1] < D[r][n + 1]) r = i;
    if (D[r][n + 1] < -EPS) {
      Pivot(r, n);
      if (!Simplex(1) || D[m + 1][n + 1] < -EPS)
        return -numeric_limits<long double>::infinity();
      for (long long i = 0; i < m; i++)
        if (B[i] == -1) {
          long long s = -1;
          for (long long j = 0; j <= n; j++) {
            if (s == -1 || D[i][j] < D[i][s] ||
                D[i][j] == D[i][s] && N[j] < N[s])
              s = j;
            Pivot(i, s);
          }
        }
    }
    if (!Simplex(2)) return numeric_limits<long double>::infinity();
    first = vector<long double>(n);
    for (long long i = 0; i < m; i++)
      if (B[i] < n) first[B[i]] = D[i][n + 1];
    return D[m][n + 1];
  }
};
long long solve() {
  long long n, m;
  cin >> n >> m;
  vector<long double> b(m, -1);
  vector<long double> c(n);
  vector<vector<long double>> a(m, vector<long double>(n, 0));
  for (long long i = 0; i < m; i++) {
    long long u, v, w;
    cin >> u >> v >> w;
    u--;
    v--;
    c[u] -= w;
    c[v] += w;
    a[i][u] = -1;
    a[i][v] = 1;
  }
  simplex solver(a, b, c);
  vector<long double> res;
  solver.Solve(res);
  vector<long long> ans(n);
  long long mn = 1e18;
  for (long long i = 0; i < n; i++) {
    ans[i] = (long long)(res[i] + 0.5);
    mins(mn, ans[i]);
  }
  for (long long i = 0; i < n; i++) {
    cout << ans[i] - mn << " ";
  }
  cout << "\n";
  return 0;
}
signed main() {
  ios_base::sync_with_stdio(0);
  cin.tie(0);
  cout.tie(0);
  long long t = 1;
  while (t--) {
    solve();
  }
  return 0;
}
