#include <bits/stdc++.h>
using namespace std;

typedef long long ll;
const ll INF = 1e18;
const int MAXN = 200005;

struct Edge {
    int u, v, w;
};

int n, m;
vector<pair<int, int>> adj[MAXN];
ll dist[MAXN];
vector<int> dag[MAXN];
Edge edges[300005];

// Dominator Tree (Lengauer-Tarjan)
namespace DominatorTree {
    vector<int> g[MAXN], rg[MAXN], bucket[MAXN], tree[MAXN];
    int sdom[MAXN], idom[MAXN], ancestor[MAXN], best[MAXN], semi[MAXN];
    int pos[MAXN], vertex[MAXN], parent[MAXN], sz[MAXN], t;

    void dfs(int u) {
        pos[u] = ++t; vertex[t] = u;
        for (int v : g[u]) {
            if (!pos[v]) {
                parent[pos[v] = ++t] = pos[u]; // Simplified for logic
                // Thực tế cần gọi đệ quy đúng chuẩn
            }
        }
    }

    // Để đơn giản và hiệu quả, ta sử dụng cấu trúc dựng sẵn
    int dfn[MAXN], rev[MAXN], fa[MAXN], semi_node[MAXN], idom_node[MAXN], path[MAXN], min_semi[MAXN], timer;

    void dfs_dt(int u) {
        dfn[u] = ++timer; rev[timer] = u;
        for (int v : g[u]) {
            if (!dfn[v]) {
                fa[v] = u;
                dfs_dt(v);
            }
        }
    }

    int find(int v) {
        if (path[v] == v) return v;
        int root = find(path[v]);
        if (dfn[semi_node[min_semi[path[v]]]] < dfn[semi_node[min_semi[v]]])
            min_semi[v] = min_semi[path[v]];
        return path[v] = root;
    }

    int eval(int v) {
        find(v);
        return min_semi[v];
    }

    void build(int s) {
        dfs_dt(s);
        for (int i = timer; i >= 2; i--) {
            int v = rev[i];
            for (int u : rg[v]) {
                if (!dfn[u]) continue;
                int w = eval(u);
                if (dfn[semi_node[w]] < dfn[semi_node[v]]) semi_node[v] = semi_node[w];
            }
            bucket[semi_node[v]].push_back(v);
            int p = fa[v];
            path[v] = p;
            for (int u : bucket[p]) {
                int w = eval(u);
                idom_node[u] = (semi_node[w] == semi_node[u] ? p : w);
            }
            bucket[p].clear();
        }
        for (int i = 2; i <= timer; i++) {
            int v = rev[i];
            if (idom_node[v] != semi_node[v]) idom_node[v] = idom_node[idom_node[v]];
            tree[idom_node[v]].push_back(v);
        }
    }

    int ans[MAXN];
    void dfs_size(int u) {
        ans[u] = 1;
        for (int v : tree[u]) {
            dfs_size(v);
            ans[u] += ans[v];
        }
    }
}

void dijkstra(int s) {
    fill(dist, dist + n + 1, INF);
    priority_queue<pair<ll, int>, vector<pair<ll, int>>, greater<pair<ll, int>>> pq;
    dist[s] = 0;
    pq.push({0, s});
    while (!pq.empty()) {
        ll d = pq.top().first;
        int u = pq.top().second;
        pq.pop();
        if (d > dist[u]) continue;
        for (auto& edge : adj[u]) {
            if (dist[edge.first] > dist[u] + edge.second) {
                dist[edge.first] = dist[u] + edge.second;
                pq.push({dist[edge.first], edge.first});
            }
        }
    }
}

int main() {
    ios::sync_with_stdio(false); cin.tie(0);
    cin >> n >> m;
    for (int i = 0; i < m; i++) {
        int u, v, w; cin >> u >> v >> w;
        adj[u].push_back({v, w});
        adj[v].push_back({u, w});
        edges[i] = {u, v, w};
    }

    dijkstra(1);

    for (int i = 1; i <= n; i++) {
        DominatorTree::semi_node[i] = DominatorTree::path[i] = DominatorTree::min_semi[i] = i;
    }

    for (int i = 0; i < m; i++) {
        int u = edges[i].u, v = edges[i].v, w = edges[i].w;
        if (dist[u] + w == dist[v]) {
            DominatorTree::g[u].push_back(v);
            DominatorTree::rg[v].push_back(u);
        } else if (dist[v] + w == dist[u]) {
            DominatorTree::g[v].push_back(u);
            DominatorTree::rg[u].push_back(v);
        }
    }

    DominatorTree::build(1);
    DominatorTree::dfs_size(1);

    for (int i = 1; i <= n; i++) {
        cout << DominatorTree::ans[i] << "\n";
    }

    return 0;
}